text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
char c[99];
int n;
int main() {
scanf("%s%d", c, &n);
for (int i = 0; c[i]; i++) {
if (c[i] < 'a') c[i] += 'a' - 'A';
if (c[i] < 'a' + n) c[i] += 'A' - 'a';
}
puts(c);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string ans = "";
int n;
cin >> n;
for (int i = 0; i < s.length(); i++) s[i] |= 32;
for (int i = 0; i < s.length(); i++) {
char c = s[i];
if (c < n + 97)
ans += char(c & (127 - 32));
else
ans += char(c | 32);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int vx[] = {1, 0, -1, 0}, vy[] = {0, 1, 0, -1};
const double EPS = 1e-9;
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int daysleap[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
string str;
int a;
cin >> str >> a;
for (int i = 0; i < str.size(); i++) {
if (str[i] >= 'A' && str[i] <= 'Z') str[i] = str[i] - 'A' + 'a';
}
for (int i = 0; i < str.size(); i++) {
if (str[i] < 97 + a && str[i] >= 'a' && str[i] <= 'z')
str[i] = str[i] - 'a' + 'A';
else if (str[i] >= 97 + a && str[i] >= 'A' && str[i] <= 'Z')
str[i] = str[i] - 'A' + 'a';
}
cout << str << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string ToLower(string sOrigin) {
string ans("");
long i;
for (i = 0; i <= sOrigin.length() - 1; ++i) {
if (sOrigin[i] >= 'A' && sOrigin[i] <= 'Z')
ans += char(sOrigin[i] + ('a' - 'A'));
else
ans += sOrigin[i];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
string sOrig;
int iNum, iLength, i;
getline(cin, sOrig);
cin >> iNum;
iLength = sOrig.length() - 1;
sOrig = ToLower(sOrig);
for (i = 0; i <= iLength; ++i) {
if (sOrig[i] < 'a' + iNum) sOrig[i] = sOrig[i] + 'A' - 'a';
}
cout << sOrig;
return 0;
}
|
#include <bits/stdc++.h>
char s[1000001];
int main() {
scanf("%s", s);
int n;
scanf("%d", &n);
for (int i = 0; i < (int)strlen(s); ++i) {
if (s[i] <= 'Z' && s[i] >= 'A') {
s[i] = s[i] + 'a' - 'A';
}
if (s[i] < n + 97) {
s[i] = s[i] + 'A' - 'a';
}
}
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int num;
int main() {
cin >> s;
cin >> num;
int n = s.length();
for (int i = 0; i < n; i++) {
if (isupper(s[i])) s[i] = tolower(s[i]);
}
for (int i = 0; i < n; i++) {
char u = s[i];
if ((int)u < num + 97)
t += toupper(s[i]);
else
t += tolower(s[i]);
}
cout << t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100];
int main() {
int i, x, l;
scanf("%s", s);
scanf("%d", &x);
l = strlen(s);
for (i = 0; i < l; i++)
if (s[i] < 'a') s[i] = s[i] - 'A' + 'a';
for (i = 0; i < l; i++)
if (s[i] < x + 'a') s[i] = s[i] - 'a' + 'A';
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k, i;
cin >> k;
for (i = 0; i < s.length(); i++)
if (tolower(s[i]) < 97 + k)
s[i] = toupper(s[i]);
else
s[i] = tolower(s[i]);
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, f, g, h, j, i;
string s, n, p;
int main() {
cin >> s >> a;
b = s.size();
for (i = 0; i < b; i++) {
if ((int)s[i] < a + 97 && s[i] >= 'a') s[i] = s[i] - 32;
if ((int)s[i] >= a + 65 && s[i] <= 'Z') s[i] = s[i] + 32;
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
int x;
cin >> n >> x;
string q = "";
for (int i = 0; i < n.size(); i++) {
if (n[i] <= 'Z') n[i] += 32;
int kk = n[i];
if (kk < x + 97) {
q = q + (char)(n[i] - 32);
} else {
q = q + n[i];
}
}
cout << q;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int x;
cin >> x;
string k = s;
s = "";
for (int i = 0, _e(k.size()); i < _e; i++) s += tolower(k[i]);
string res = "";
for (int i = 0, _e(s.size()); i < _e; i++) {
char k = s[i];
if (k < x + 97)
res += toupper(k);
else
res += tolower(k);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long A = 100000000000000LL, N = 10000;
string a;
long long i, j, n, m;
int main() {
cin >> a;
n = a.size();
cin >> m;
for (i = 0; i < n; i++)
if (a[i] >= 'A' && a[i] <= 'Z') a[i] = a[i] - 'A' + 'a';
for (i = 0; i < n; i++)
if (a[i] < 'a' + m) a[i] = a[i] - 'a' + 'A';
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
void setup() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
int main() {
string a;
int n, i;
cin >> a;
cin >> n;
for (i = 0; a[i] != '\0'; i++) a[i] = tolower(a[i]);
for (i = 0; a[i] != '\0'; i++) {
if (a[i] < n + 97) a[i] += 'A' - 'a';
}
cout << a << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
char H;
string s;
int num;
cin >> s >> num;
for (unsigned int i = 0; i < s.size(); i++) {
if ((int)tolower(s[i]) < num + 97)
H = (toupper(s[i]));
else
H = (tolower(s[i]));
cout << H;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[55];
int b;
cin >> s;
cin >> b;
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] < 'a') {
s[i] += 32;
}
}
for (int i = 0; i < len; i++) {
if (s[i] < b + 'a') {
s[i] -= 32;
}
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char instr[51], outstr[51] = {}, ch;
int n, i;
cin >> instr;
cin >> n;
for (i = 0; i < strlen(instr); i++) {
if (instr[i] < 97) instr[i] += 32;
}
for (i = 0; i < strlen(instr); i++) {
ch = instr[i];
if (int(ch) < (n + 97)) {
outstr[i] = ch - 32;
} else {
outstr[i] = ch;
}
}
cout << outstr;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s27;
int n16;
cin >> s27 >> n16;
string res4;
for (int i26 = 0; i26 < s27.size(); i26++) {
int a19 = s27[i26];
if ('a' <= a19 && a19 <= 'z')
a19 -= 'a';
else
a19 -= 'A';
if (a19 < n16)
res4.push_back('A' + a19);
else
res4.push_back('a' + a19);
}
cout << res4 << "\n";
}
|
#include <bits/stdc++.h>
const double eps = 1e-9;
const double pi = acos(-1);
const int oo = 1000000000;
const int mod = 1000000007;
const double E = 2.7182818284590452353602874713527;
using namespace std;
string a;
int main() {
int b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++) {
if (a[i] >= 'A' && a[i] <= 'Z') a[i] += 'a' - 'A';
if (a[i] - 'a' < b) a[i] -= 'a' - 'A';
}
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-6;
char s[55];
int main() {
int n;
scanf("%s%d", s, &n);
for (int i = 0; s[i]; i++)
if (tolower(s[i]) < 'a' + n)
printf("%c", toupper(s[i]));
else
printf("%c", tolower(s[i]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926536;
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void TXT() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
FAST();
string s;
cin >> s;
int n;
cin >> n;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] += 32;
if (s[i] - n < 'a') {
if (s[i] >= 'a' && s[i] <= 'z') s[i] -= 32;
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n, l, i;
char ch[100], ch1[100];
string s = "", ss = "";
scanf("%s", ch);
scanf("%d", &n);
l = strlen(ch);
for (i = 0; i < l; i++) {
if (ch[i] >= 'A' && ch[i] <= 'Z') ch[i] = (ch[i] - 'A') + 'a';
}
for (i = 0; i < l; i++) {
a = ch[i];
if (a < 97 + n)
s += (ch[i] - 'a') + 'A';
else
s += ch[i];
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
char a[100];
int main() {
int i, n, m;
scanf("%s%d", a, &m);
n = strlen(a);
for (i = 0; i < n; i++)
if (a[i] < 'a') a[i] += 'a' - 'A';
for (i = 0; i < n; i++) {
if (a[i] < m + 97) {
a[i] -= 'a' - 'A';
}
}
puts(a);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[64];
int d;
scanf("%s%d", str, &d);
for (int i = 0; str[i]; i++)
if (tolower(str[i]) < 'a' + d)
printf("%c", toupper(str[i]));
else
printf("%c", tolower(str[i]));
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int compare(const void* a, const void* b) { return (*(int*)a - *(int*)b); }
int main() {
string buffer;
cin >> buffer;
int c;
cin >> c;
c += 97;
for (int i = 0; i < buffer.size(); i++) {
buffer[i] = tolower(buffer[i]);
if (buffer[i] < c) buffer[i] = toupper(buffer[i]);
}
cout << buffer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int tmax = (int)1e5 + 100;
char str[100];
int main() {
scanf("%s", str);
int sz = strlen(str);
int N;
scanf("%d", &N);
string now = "";
for (int i = 0; i < sz; i++) {
char c = str[i];
if (tolower(c) < ('a' + N))
now += toupper(c);
else
now += tolower(c);
}
printf("%s\n", now.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
char s[maxn];
int main() {
ios::sync_with_stdio(false);
int n;
scanf("%s %d", s, &n);
int len = strlen(s);
for (int i = 0; i < len; ++i) {
if (isupper(s[i])) s[i] = s[i] - 'A' + 'a';
}
n += 97;
for (int i = 0; i < len; ++i) {
if (s[i] < n) {
s[i] = s[i] - 'a' + 'A';
}
}
puts(s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> s >> n;
string res;
std::transform(s.begin(), s.end(), s.begin(), ::tolower);
for (int i = 0; i < s.length(); i++) {
char c = s[i];
if (c < n + 97) {
res = res + (char)toupper(c);
} else {
res = res + (char)tolower(c);
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, s1;
string s;
cin >> s >> a;
for (unsigned int i = 0; i < s.length(); i++) {
s[i] = tolower(s[i]);
}
for (unsigned int i = 0; i < s.length(); i++) {
s1 = s[i];
if (s1 < a + 97) {
s[i] = toupper(s[i]);
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
char Input[100];
int i, L, c;
char x;
int main() {
scanf("%s", Input);
scanf("%d", &c);
L = strlen(Input);
for (i = 0; i < L; i++)
if (Input[i] <= 90) Input[i] += 32;
for (i = 0; i < L; i++)
if (Input[i] < (c + 97)) Input[i] -= 32;
printf("%s\n", Input);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100];
int a;
cin >> str;
cin >> a;
for (int i = 0; i < strlen(str); i++)
if (str[i] <= 'Z' && str[i] >= 'A') str[i] = str[i] + 32;
int t = a + 97;
for (int i = 0; i < strlen(str); i++) {
if (str[i] < t) {
str[i] = str[i] - 'a' + 'A';
}
}
cout << str << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, res;
int a;
cin >> s >> a;
res = s;
int i;
for (i = 0; i < s.length(); i++) {
int c = (int)(s[i]);
if (c > 96) c -= 32;
if (c >= a + 65)
res[i] = (char)(c + 32);
else
res[i] = (char)c;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[55];
int n;
cin >> s >> n;
int l = strlen(s);
for (int i = 0; i < l; i++) {
if (s[i] >= 'a' && s[i] <= 'z' && s[i] - 'a' + 1 <= n)
s[i] = s[i] + 'A' - 'a';
if (s[i] >= 'A' && s[i] <= 'Z' && s[i] - 'A' + 1 > n)
s[i] = s[i] - 'A' + 'a';
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int a;
while (cin >> s >> a) {
int n = s.size();
for (int i = 0; i < n; ++i) {
s[i] = tolower(s[i]);
if (s[i] < 'a' + a) {
s[i] = toupper(s[i]);
}
}
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int asalmi(int x) {
int i, k = (int)sqrt(x);
for (i = 2; i <= k; i++)
if (x % i == 0) return 0;
return 1;
}
int ters(int x) {
int bas = 0, t = x, i, k = 0;
while (t) {
bas++;
t /= 10;
}
for (i = 1; i <= bas; i++) {
k *= 10;
k += x % 10;
x /= 10;
}
return k;
}
using namespace std;
long long m, n;
void read() {}
void solve() {
int n;
string s;
cin >> s >> n;
for (int i = 0; i <= int(s.size()) - 1; i += 1) {
s[i] = tolower(s[i]);
if (s[i] - 'a' < n) s[i] = toupper(s[i]);
}
cout << s << endl;
}
void write() { int i, j; }
int main() {
read();
solve();
write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
const double eps = 1e-7;
const double DINF = 1e100;
const int INF = 1000000006;
const long long LINF = 1000000000000000005ll;
string s;
int main() {
cin >> s;
int m;
cin >> m;
for (int i = 0; i < s.size(); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] - 'A' + 'a';
}
for (int i = 0; i < s.size(); ++i) {
if (s[i] < m + 'a') s[i] = s[i] - 'a' + 'A';
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
int k;
string str;
int main() {
cin >> str >> k;
for (int i = 0; i < str.length(); i++) {
if (islower(str[i]) && str[i] < 'a' + k) str[i] += 'A' - 'a';
if (isupper(str[i]) && str[i] >= 'A' + k) str[i] -= 'A' - 'a';
}
cout << str << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, q = "";
cin >> s;
int n;
cin >> n;
transform(s.begin(), s.end(), s.begin(), ::tolower);
for (int i = 0; i < s.length(); i++) {
char c = s[i];
if (c < n + 97) {
if (c > 'Z') {
c -= 'a';
c += 'A';
}
q += c;
} else {
if (c < 'A') {
c -= 'A';
c += 'a';
}
q += c;
}
}
cout << q;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int n;
cin >> n;
int siz = str.size(), i = 0;
while (i < siz) {
if (str[i] < 97) {
str[i] = char(str[i] + 32);
}
i++;
}
i = 0;
while (i < siz) {
if (str[i] < n + 97) {
str[i] = char(str[i] - 32);
}
i++;
}
cout << str << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1E-7;
char s[105];
int x;
int main() {
scanf("%s", s);
scanf("%d", &x);
int n = strlen(s);
for (int i = 0; i < n; ++i)
if ('A' <= s[i] && s[i] <= 'Z') s[i] = 'a' + s[i] - 'A';
for (int i = 0; i < n; ++i)
if ((int)s[i] < x + 97) {
putchar(s[i] - 'a' + 'A');
} else
putchar(s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int a;
int main() {
int i, d = 'A' - 'a';
cin >> s;
cin >> a;
for (i = 0; i < s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
if (int(s[i] - 'a') + 1 <= a) s[i] += d;
} else if (s[i] >= 'A' && s[i] <= 'Z') {
if (int(s[i] - 'A') + 1 > a) s[i] -= d;
}
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a;
cin >> a;
string ans = "";
for (int i = 0; i < s.length(); i++) {
char c = s[i];
if (tolower(c) < a + 'a') {
ans += toupper(c);
} else {
ans += tolower(c);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void return_print(string x);
int main() {
string a;
int len, b;
getline(cin, a);
cin >> b;
len = a.size();
for (int i = 0; i < len; i++) {
if (a[i] >= 'A' && a[i] <= 'Z') a[i] = 'a' + a[i] - 'A';
if ((a[i] - 'a' + 1) <= b) a[i] = 'A' + a[i] - 'a';
}
cout << a;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int a;
cin >> s;
cin >> a;
for (int i = 0; i < s.size(); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] += 32;
}
}
for (int i = 0; i < s.size(); ++i) {
if (a + 97 > s[i]) {
s[i] -= 32;
}
}
cout << s << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[5555], b[5555];
bool mark[5555], moze[5555];
int main() {
int n, x, i, j, t, q, br, of, bb;
scanf("%d%d", &n, &x);
for (i = 0; i <= n; i++) mark[i] = false;
for (i = 1; i <= n; i++) {
scanf("%d", &s[i]);
mark[s[i]] = true;
}
br = 0;
of = 0;
q = -1;
for (i = 1; i <= n; i++) {
if (!mark[i]) {
t = i;
bb = 0;
b[br] = 0;
while (t != 0) {
b[br]++;
if (bb) of++;
if (t == x) {
of++;
bb = 1;
}
t = s[t];
}
if (bb) q = br;
br++;
}
}
for (i = 0; i <= 1555; i++) moze[i] = false;
moze[of] = true;
for (i = 0; i < br; i++)
if (i != q) {
for (j = 1234; j > b[i]; j--)
if (moze[j - b[i]]) moze[j] = true;
}
for (i = 1; i <= 1234; i++)
if (moze[i]) printf("%d\n", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Length[1001], n, x, a[1001], Concern, Pos, Ppl;
vector<int> Queues, adj[1001], Ans;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> x;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i]) adj[a[i]].push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (a[i] == 0) {
Ppl = i;
int len = 0;
while (Ppl) {
++len;
if (Ppl == x) Concern = i, Pos = len;
if ((int)adj[Ppl].size())
Ppl = adj[Ppl][0];
else
Ppl = 0;
}
if (Concern != i) Queues.push_back(len);
}
}
for (int i = Queues.size() - 1; i >= 0; --i) {
vector<int> Add;
for (int j = 0; j < Ans.size(); ++j) {
if (!Length[Ans[j] + Queues[i]])
Add.push_back(Ans[j] + Queues[i]), Length[Ans[j] + Queues[i]] = 1;
}
for (int j = 0; j < Add.size(); ++j) Ans.push_back(Add[j]);
if (!Length[Queues[i]]) Ans.push_back(Queues[i]), Length[Queues[i]] = 1;
}
cout << Pos << "\n";
sort(Ans.begin(), Ans.end());
for (int i = 0; i < Ans.size(); ++i) cout << Pos + Ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, first, a[1111];
int b[1111], ub = -1, pos;
vector<int> c[1111];
vector<int> d;
int can[1111];
void go(int p, int v) {
if (v == -1) return;
if (v == first) ub = p;
c[p].push_back(v);
go(p, a[v]);
}
int main() {
scanf("%d%d", &n, &first);
--first;
for (int i = 0; i < n; ++i) b[i] = -1;
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
a[i]--;
b[a[i]] = i;
}
for (int i = 0; i < n; ++i) {
c[i].clear();
if (b[i] == -1) {
go(i, i);
}
}
assert(ub >= 0);
d.clear();
for (int i = 0; i < c[ub].size(); ++i) {
if (c[ub][i] == first) pos = c[ub].size() - i;
}
for (int i = 0; i < n; ++i) {
if (i == ub) continue;
if (c[i].size() != 0) d.push_back(c[i].size());
}
sort(d.begin(), d.end());
for (int i = 0; i < n; ++i) can[i] = 0;
can[0] = 1;
for (int i = 0; i < d.size(); ++i) {
for (int j = n - 1; j >= 0; --j) {
if ((j + d[i] < n) && (can[j] == 1)) can[j + d[i]] = 1;
}
}
for (int i = 0; i < n; ++i) {
if (can[i]) cout << i + pos << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
int n, k, ord[10001], out[10001], t[10001], len[10001], fa = 1, r = 1,
ma[10000002];
int main() {
cin >> n >> k;
int q = 1, cu = 1;
for (long long i = 1; i <= n; i++) {
out[i] = 0;
t[i] = 0;
}
for (long long i = 1; i <= n; i++) {
cin >> ord[i];
t[ord[i]] = 1;
}
int yes = 1;
while (yes) {
int v = -1;
for (long long i = 1; i <= n; i++) {
if ((t[i] == 0) && (ord[i] != 0)) {
v = i;
}
}
if (v == -1) {
yes = 0;
} else {
int l = 1;
int fi = 0;
while (ord[v] != 0) {
if (v == k) {
q = l;
fi = 1;
}
int tmp = ord[v];
ord[v] = -1;
t[v] = -1;
v = tmp;
l++;
}
if (v == k) {
q = l;
fi = 1;
}
ord[v] = -1;
t[v] = -1;
if (fi) {
q = l - q + 1;
cu = l;
}
len[r++] = l;
}
}
for (long long i = 1; i <= n; i++) {
if (ord[i] == 0) {
len[r++] = 1;
}
}
int b = 1;
ma[b] = q;
out[q] = 1;
int check = 0;
r--;
for (long long i = 1; i <= r; i++) {
if ((!check) && (len[i] == cu)) {
check = 1;
} else {
int t[1001];
for (long long j = 1; j <= n; j++) {
t[j] = 0;
}
for (long long j = 1; j <= n; j++) {
if ((out[j] > 0) && ((len[i] + j) <= n)) {
t[len[i] + j] = 1;
}
}
for (long long j = 1; j <= n; j++) {
out[j] = max(out[j], t[j]);
}
}
}
for (long long i = 1; i <= n; i++) {
if (out[i]) {
cout << i << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int dep[N], fa[N], tot[N];
bool dp[N], vis[N];
int find(int x) {
if (x == fa[x])
return x;
else {
int f = fa[x];
fa[x] = find(f);
dep[x] += dep[f];
return fa[x];
}
}
void make(int x, int y) {
int fx = find(x);
fa[y] = x;
dep[y]++;
tot[fx] += tot[y];
tot[y] = 0;
}
int main() {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) {
fa[i] = i;
dep[i] = 0;
tot[i] = 1;
}
int f;
for (int i = 1; i <= n; i++) {
scanf("%d", &f);
if (f != 0) make(f, i);
}
vector<int> a;
memset(vis, false, sizeof(vis));
int fx = find(x), s = dep[x] + 1;
vis[fx] = true;
for (int i = 1; i <= n; i++) {
int f = find(i);
if (!vis[f]) {
vis[f] = true;
a.push_back(tot[f]);
}
}
memset(dp, false, sizeof(dp));
dp[0] = true;
for (int i = 0; i < a.size(); i++) {
int v = a[i];
for (int i = n; i >= v; i--) {
if (dp[i - v]) dp[i] = true;
}
}
for (int i = 0; i + s <= n; i++) {
if (dp[i]) printf("%d\n", i + s);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int arr[N], cnt, n, k;
bool vis[N], found;
int dp[N];
vector<int> tree[N], v;
void dfs(int u) {
if (u == k) found = 1;
cnt++;
vis[u] = 1;
for (int i = 0; i < tree[u].size(); i++) {
int to = tree[u][i];
dfs(to);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
if (arr[i] != 0) tree[arr[i]].push_back(i);
}
int infront = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] == 0) {
found = 0;
cnt = 0;
dfs(i);
if (!found)
v.push_back(cnt);
else {
int cur = k;
while (arr[cur] != 0) {
infront++;
cur = arr[cur];
}
infront++;
}
}
}
sort(v.begin(), v.end());
dp[infront] = 1;
for (int i = 0; i < v.size(); i++) {
for (int j = 1000; j >= 1; j--)
if (dp[j]) dp[j + v[i]] = 1;
}
for (int i = 1; i <= n; i++)
if (dp[i]) cout << i << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k, n, x, a[1111], trace[1111], dem[1111], b[1111];
int main() {
cin >> n >> x;
for (int i = 1; i <= n; i++) {
dem[i] = 1;
trace[i] = i;
}
k = 0;
int z;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > 0) {
trace[i] = a[i];
z = i;
while (trace[z] != z) z = trace[z];
dem[z] += dem[i];
dem[i] = 0;
}
}
for (int j = 1; j <= n; j++) {
z = j;
if (z == x) {
++k;
continue;
}
while (trace[z] != z) {
z = trace[z];
if (z == x) {
++k;
break;
}
}
}
int t;
t = x;
while (trace[t] != t) t = trace[t];
k = dem[t] - k + 1;
dem[t] = 0;
b[0] = 1;
for (int i = 1; i <= n; i++) {
if (dem[i] > 0) {
for (int j = 0; j <= n; j++) {
if (b[j] == 1 && b[j + dem[i]] == 0) b[j + dem[i]] = 2;
}
for (int j = 0; j <= n; j++) {
if (b[j] == 2) b[j] = 1;
}
}
}
for (int i = 0; i <= n; i++) {
if (b[i] == 1) cout << i + k << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long _set(long long N, long long pos) { return N = N | (1 << pos); }
long long _reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool _check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
bool _upper(char a) { return a >= 'A' && a <= 'Z'; }
bool _lower(char a) { return a >= 'a' && a <= 'z'; }
bool _digit(char a) { return a >= '0' && a <= '9'; }
long long dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
long long dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
vector<vector<long long> > g;
long long t[1010], ch, x, f, pos, n;
bool vis[1010];
void dfs(long long u) {
if (!vis[u]) vis[u] = true;
ch++;
if (u == x) pos = ch, f = 1;
for (auto i : g[u]) {
dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> x;
g.resize(n + 5);
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
if (!a) {
t[i] = 1;
continue;
}
g[a].push_back(i);
}
vector<long long> cl;
for (long long i = 1; i <= n; i++) {
if (t[i]) {
dfs(i);
if (!f) cl.push_back(ch);
ch = 0, f = 0;
}
}
bitset<1010> memo;
memo[0] = 1;
for (auto i : cl) memo |= memo << i;
for (int i = 0; i < 1010; i++)
if (memo[i] == 1) cout << i + pos << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int indeg[1024];
int adj[1024];
bool mark[1024];
int depth[1024];
int n, id, comp;
void dfs(int x, int d) {
comp++;
mark[x] = true;
depth[x] = d;
if (adj[x] != 0) {
indeg[adj[x]]--;
dfs(adj[x], d + 1);
}
}
bool dp[1024][1024];
int main() {
memset(indeg, 0, sizeof indeg);
int front, back;
cin >> n >> id;
for (int i = 1; i <= n; i++) {
cin >> front;
indeg[front]++;
adj[i] = front;
}
int myGroup = -1;
memset(mark, 0, sizeof mark);
vector<int> v;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (indeg[j] == 0 && mark[j] == false) {
comp = 0;
dfs(j, 1);
if (mark[id] == true && myGroup == -1)
myGroup = comp;
else
v.push_back(comp);
}
}
if (v.size()) {
memset(dp, 0, sizeof dp);
dp[0][0] = true;
dp[0][v[0]] = true;
for (int i = 1; i < v.size(); i++) {
for (int j = 0; j < 1024; j++) {
dp[i][j] = dp[i - 1][j];
if (j - v[i] >= 0) dp[i][j] |= dp[i - 1][j - v[i]];
}
}
}
int Left, Right;
Left = depth[id] - 1;
Right = myGroup - depth[id];
dp[0][0] = true;
for (int i = 1; i <= n; i++) {
front = i - 1;
back = n - i;
back -= Left;
front -= Right;
int row = max((int)v.size() - 1, 0);
if (front >= 0 && back >= 0 && dp[row][front]) cout << i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fl[20005];
int mas[20005];
int res[3004];
int main() {
memset(fl, 0, sizeof(fl));
memset(res, 0, sizeof(res));
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> mas[i];
fl[mas[i]] = 1;
}
vector<int> arr(0);
int d = 1;
for (int i = 1; i <= n; i++) {
if (fl[i]) continue;
int x = i;
int len = 1;
bool f = false;
if (x == m) f = true;
while (mas[x]) {
len++;
x = mas[x];
if (x == m) {
f = true;
len = 1;
}
}
if (f)
d = len;
else
arr.push_back(len);
}
res[0] = 1;
for (int i = 0; i < arr.size(); i++)
for (int j = 1000; j >= 0; j--)
if (res[j]) res[j + arr[i]] = 1;
int i = 0;
while (i + d <= n) {
if (res[i]) cout << (i + d) << endl;
i++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(unsigned long long &x) { scanf("%I64u", &x); }
void RD(unsigned int &x) { scanf("%u", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(unsigned int &x, unsigned int &y) { scanf("%u%u", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void RD(long long &x, long long &y, long long &z) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
}
void RD(unsigned int &x, unsigned int &y, unsigned int &z) {
scanf("%u%u%u", &x, &y, &z);
}
void RD(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void RD(char &x) { x = getchar(); }
void RD(char *s) { scanf("%s", s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(int x, int y) { printf("%d %d\n", x, y); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(unsigned int x) { printf("%u\n", x); }
void PR(unsigned long long x) { printf("%I64u\n", x); }
void PR(double x) { printf("%.2lf\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const long long inf = ((long long)1) << 60;
const double dinf = 1e50;
const int INF = 1000000005;
const int N = 1005;
int pre[N], Next[N], n, m;
int d[N];
vector<int> V;
int flag = -1;
int DFS(int x) {
if (!x) return 0;
int t = DFS(Next[x]);
if (x == m) flag = t;
return t + 1;
}
int main() {
RD(n);
RD(m);
int i, x;
for (i = 1; i <= n; i++) {
RD(x);
if (x) {
pre[i] = x;
Next[x] = i;
d[i]++;
}
}
int K, M;
for (i = 1; i <= n; i++)
if (!d[i]) {
flag = -1;
int x = DFS(i);
if (flag != -1) {
M = flag + 1;
K = x - M;
} else
V.push_back(x);
}
int f[N];
memset(f, -1, sizeof(f));
f[0] = 1;
int s = V.size();
for (i = 1; i <= s; i++) {
int x = V[i - 1];
int j;
for (j = n; j >= 0; j--)
if (f[j] != -1) {
f[j + x] = 1;
}
}
V.clear();
for (i = 0; i < n + 1; i++)
if (f[i] != -1) {
V.push_back(i + K + 1);
}
sort(V.begin(), V.end());
printf("%d\n", V[0]);
for (i = 1; i < V.size(); i++)
if (V[i] != V[i - 1]) PR(V[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int par[1010];
int cnt[1010];
bool ba[1010];
vector<int> v;
int n, m, k;
void init() {
for (int i = 0; i <= n; i++) par[i] = i;
}
int getPar(int a) {
if (par[a] == a)
return a;
else
return par[a] = getPar(par[a]);
}
void merge(int a, int b) {
int pa = getPar(a), pb = getPar(b);
par[pa] = pb;
}
void countPar() {
for (int i = 1; i <= n; i++) {
cnt[getPar(i)]++;
if (!ba[par[i]]) {
ba[par[i]] = true;
v.push_back(par[i]);
}
}
}
int gDepth(int a) {
if (par[a] == a) return 1;
return gDepth(par[a]) + 1;
}
int main() {
cin >> n >> m;
init();
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
if (a == 0) continue;
par[i] = a;
}
k = gDepth(m);
countPar();
memset(ba, 0, sizeof(ba));
ba[k] = true;
int l = v.size();
for (int i = 0; i < l; i++) {
for (int j = n; j > 0; j--) {
if (v[i] != par[m] && j - cnt[v[i]] > 0 && ba[j - cnt[v[i]]])
ba[j] = true;
}
}
for (int i = 1; i <= n; i++)
if (ba[i]) cout << i << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 10;
const int MOD = 1000000007;
int n, x;
int at;
int pa[1010], d[1010], s[1010];
int a[1010];
int findset(int x) {
if (pa[x] != x) {
int root = findset(pa[x]);
d[x] += d[pa[x]];
return pa[x] = root;
} else
return x;
}
int dp[1010];
int main() {
scanf("%d %d", &n, &x);
for (int i = 0; i < n; ++i) scanf("%d", &a[i + 1]);
for (int i = 1; i <= n; ++i) {
s[i] = 1;
pa[i] = i;
}
for (int i = 1; i <= n; ++i) {
if (a[i] != 0) {
pa[i] = a[i];
d[i] = 1;
int u = findset(i);
s[u] += s[i];
}
}
map<int, int> tt;
int mm = findset(x);
for (int i = 1; i <= n; ++i)
if (findset(i) != mm) tt[findset(i)] = s[findset(i)];
dp[d[x] + 1] = 1;
int kk = 2;
for (map<int, int>::iterator it = tt.begin(); it != tt.end(); ++kk, ++it)
for (int i = 1; i <= n; ++i)
if (dp[i] && dp[i] != kk && (it->second) + i <= n &&
!dp[it->second + i]) {
dp[i + (it->second)] = kk;
}
for (int i = 1; i <= n; ++i)
if (dp[i]) printf("%d\n", i);
}
|
#include <bits/stdc++.h>
using namespace std;
int go(int curr, vector<int> &vis, vector<vector<int>> &adj, int num) {
vis[curr] = num;
int ret = 1;
for (int x : adj[curr]) {
if (vis[x] == -1) {
ret += go(x, vis, adj, num + 1);
}
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x;
cin >> n >> x;
vector<vector<int>> adj(n + 1);
vector<int> par(n + 1, -1);
for (int i = 1; i <= n; i++) {
int y;
cin >> y;
if (y) {
adj[i].push_back(y);
adj[y].push_back(i);
par[i] = y;
}
}
vector<int> vis(n + 1, -1);
int mySize;
int myBefore, myAfter;
vector<int> coins;
for (int i = 1; i <= n; i++) {
int sz = 0;
if (adj[i].size() <= 1 && vis[i] == -1) {
sz = go(i, vis, adj, 1);
}
if (sz) {
if (vis[x] != 0 && vis[x] != -1) {
mySize = sz;
myBefore = vis[x] - 1;
myAfter = mySize - vis[x];
vis[x] = 0;
} else
coins.push_back(sz);
}
}
myBefore = 0;
while (par[x] != -1) {
x = par[x];
myBefore++;
}
vector<bool> pos(n + 1, 0);
pos[0] = true;
for (int i = 0; i < coins.size(); i++) {
for (int w = n; w >= 0; w--) {
if (pos[w] && w + coins[i] <= n) pos[w + coins[i]] = true;
}
}
for (int i = 0; i + mySize <= n; i++) {
int left = i;
int right = n - mySize - left;
if (pos[left] || pos[right]) {
cout << i + myBefore + 1 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sa[1007], n, t, x, d[1007], s;
bool f[1007], c[1007];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) {
scanf("%d", &t), sa[t] = i;
if (t == 0) c[i] = 1;
}
for (int i = 1; i <= n; ++i) {
if (!c[i]) continue;
int kt = 1, t2 = 1, j = i;
while (j) {
if (j == x) kt = 0, t = t2;
j = sa[j], ++t2;
}
if (kt) d[++s] = t2 - 1;
}
f[0] = 1;
for (int i = 1; i <= s; ++i)
for (int j = 1000; j >= d[i]; --j)
if (f[j - d[i]]) f[j] = 1;
printf("%d\n", t);
for (int i = 1; i <= n; ++i)
if (f[i] && t + i <= n) printf("%d\n", t + i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long visit[1007], dp[1007], dp1[1007], n, d, chk;
vector<long long> v[1007], v1;
long long solve(long long i, long long l, long long sum) {
if (i == l) dp[sum] = 1;
if (dp[sum] != -1) return dp[sum];
}
long long dfs(long long node) {
visit[node] = 1;
if (node == d) {
chk = 1;
return 1;
}
long long res = 1, i, x;
for (i = 0; i < v[node].size(); i++) {
x = v[node][i];
if (!visit[x]) {
res += dfs(x);
}
}
return res;
}
int main() {
long long i, x, val, k, tot = 0, sum;
cin >> n >> d;
for (i = 1; i <= n; i++) {
cin >> x;
v[x].push_back(i);
}
for (i = 1; i <= n; i++) visit[i] = 0;
v1.clear();
for (i = 0; i < v[0].size(); i++) {
chk = 0;
val = dfs(v[0][i]);
if (chk == 1)
k = val;
else {
v1.push_back(val);
tot += val;
}
}
for (i = 0; i <= n; i++) dp[i] = 0;
dp[0] = 1;
sort(v1.begin(), v1.end());
for (i = 0; i < v1.size(); i++) {
for (sum = n; sum >= 0; sum--) {
if (dp[sum]) dp[sum + v1[i]] = 1;
}
}
for (i = 0; i <= n; i++) {
if (dp[i] == 1) cout << i + k << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e4;
const long long INF = 1e9 + 1;
const long long MOD = 998244353;
const long double EPS = 1e-12;
const long double PI = acos(-1);
const unsigned long long PRIME = 31;
void bye() {
cout << "\n";
exit(0);
}
vector<vector<int>> g;
vector<bool> used;
vector<int> cnt;
bool f = 0;
int n, s;
void dfs(int v) {
if (v == s) {
f = 1;
}
used[v] = 1;
cnt.back()++;
for (auto to : g[v]) {
if (!used[to]) {
dfs(to);
}
}
}
int get_up(int s) {
if (!(long long)(g[s]).size()) {
return 1;
}
return 1 + get_up(g[s][0]);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> s;
s--;
g.resize(n);
used.resize(n);
vector<int> in(n);
for (int i = 0; i < n; i++) {
int p;
cin >> p;
if (!p) {
continue;
} else {
p--;
g[i].push_back(p);
in[p]++;
}
}
vector<int> q;
for (int i = 0; i < n; i++) {
if (!in[i]) {
f = 0;
cnt.push_back(0);
dfs(i);
if (!f) {
q.push_back(cnt.back());
}
}
}
if (!(long long)(q).size()) {
cout << get_up(s);
bye();
}
vector<bitset<MAXN>> dp((long long)(q).size());
dp[0][0] = 1;
dp[0][q[0]] = 1;
for (int i = 1; i < (long long)(q).size(); i++) {
dp[i] = dp[i - 1];
dp[i] |= (dp[i - 1] << q[i]);
}
for (int i = 0; i < MAXN; i++) {
if (dp[(long long)(q).size() - 1][i]) {
cout << i + get_up(s) << "\n";
}
}
bye();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2050;
int n, k;
int pre[N];
int ith[N];
int cnt[N];
int back[N];
void dfs(int now) {
if (ith[now]) return;
if (now == k) back[now] = -1;
if (pre[now]) {
dfs(pre[now]);
if (now == k) back[now] = -1;
if (back[pre[now]] == -1)
back[now] = -1;
else
back[pre[now]] = now;
ith[now] = ith[pre[now]] + 1;
} else {
ith[now] = 1;
}
}
int main(void) {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> pre[i];
for (int i = 1; i <= n; ++i) dfs(i);
vector<int> vec;
for (int i = 1; i <= n; ++i)
if (back[i] == 0) vec.push_back(ith[i]);
cnt[0] = 1;
for (auto &m : vec) {
for (int i = n; i >= 0; --i) {
if (cnt[i]) cnt[i + m] = 1;
}
}
vector<int> ans;
for (int i = 0; i <= n; ++i)
if (cnt[i]) ans.push_back(i);
for (auto &m : ans) cout << m + ith[k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
}
int vl, wh, n, nx[1005], a[1005], m;
char st[1005], dp[1005];
int main() {
read(n), read(wh);
for (int i = 1, x; i <= n; i++) read(x), x ? nx[x] = i, st[i] = 1 : 0;
for (int i = 1, c, x; i <= n; i++)
if (!st[i]) {
char tag = (c = 0) * (x = i);
while (x) c++, (x == wh ? tag = 1, vl = c : 0), x = nx[x];
if (!tag) a[++m] = c;
}
dp[0] = 1;
for (int i = 1; i <= m; i++)
for (int j = n; j >= a[i]; j--) dp[j] |= dp[j - a[i]];
for (int i = 0; i <= n; i++)
if (dp[i]) printf("%d\n", i + vl);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
int c[N], cnt, a[N], b[N], n, pos, head[N], blg, ord;
bool f[N], ans[N];
void solve(const int k) {
memset(f, 0, sizeof(f));
f[0] = true;
for (int i = 0; i < cnt; i++)
if (i != k)
for (int j = n - c[i]; j >= 0; j--)
if (f[j]) f[j + c[i]] = true;
for (int i = head[k]; i; i = b[i]) {
ord++;
if (i == pos) break;
}
for (int i = 0; i <= n; i++)
if (f[i]) ans[i + ord] = true;
}
void init() {
scanf("%d%d", &n, &pos);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
b[a[i]] = i;
}
for (int i = 1; i <= n; i++)
if (b[i] == 0) {
int j;
c[cnt] = 1;
for (j = i; a[j]; j = a[j]) {
if (j == pos) blg = cnt;
c[cnt]++;
}
if (j == pos) blg = cnt;
head[cnt] = j;
cnt++;
}
}
void output() {
for (int i = 1; i <= n; i++)
if (ans[i]) printf("%d\n", i);
}
int main() {
init();
solve(blg);
output();
}
|
#include <bits/stdc++.h>
using namespace std;
int E[1010];
int RE[1010];
int main() {
int N, x;
cin >> N >> x;
x--;
memset(RE, -1, sizeof(RE));
for (int i = 0; i < N; i++) {
cin >> E[i];
if (--E[i] != -1) {
RE[E[i]] = i;
}
}
int ln = 1;
for (; E[x] != -1; x = E[x]) {
ln++;
}
vector<int> DP(N + 1, false);
DP[ln] = 1;
for (int i = 0; i < N; i++) {
if (RE[i] != -1) continue;
int y = i;
int ln = 1;
for (; E[y] != -1; y = E[y]) {
ln++;
}
if (x == y) continue;
for (int i = N; i >= ln; i--) {
DP[i] |= DP[i - ln];
}
}
for (int i = 1; i <= N; i++) {
if (DP[i]) {
cout << i << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
typedef struct {
int a;
double p;
} tpo;
int main() {
long long i, j, n, x;
int a[2000];
int o[2000];
memset(&o, 0, sizeof(int) * 2000);
cin >> n >> x;
for (i = 0; i < n; ++i) cin >> a[i + 1];
for (i = 0; i < n; ++i)
if (a[i + 1] != 0) {
int k = a[i + 1];
while (a[k] != 0) k = a[k];
o[k] += 1;
}
int my = 0, myI = -1;
if (a[x] != 0) {
int u = a[x];
my = 1;
while (a[u] != 0) {
u = a[u];
my++;
}
myI = u;
}
int list[4000], ilist = 1;
list[0] = 0;
int blist[4000], iblist;
int cl[4000];
memset(&cl, 0, sizeof(int) * 4000);
cl[0] = 1;
for (i = 1; i <= n; ++i)
if ((a[i] == 0) && x != i && (myI != i)) {
int l = 1;
if (o[i] > 0) l = o[i] + 1;
iblist = 0;
for (j = 0; j < ilist; ++j) {
if (cl[list[j] + l] == 0) blist[iblist++] = list[j] + l;
cl[list[j] + l] = 1;
}
for (j = 0; j < iblist; ++j) list[ilist++] = blist[j];
}
for (i = 0; i <= n; ++i)
if (cl[i] == 1) cout << i + 1 + my << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1010], f[1010], b[1010];
int d[1010], a[1010];
void dfs(int x) {
if (x == 0) return;
vis[x] = true;
if (!vis[a[x]]) dfs(a[x]);
d[x] = d[a[x]] + 1;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[a[i]] = true;
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
for (int i = 1; i <= n; i++) {
if (b[i]) continue;
int temp = i;
bool flag = false;
while (temp) {
if (temp == k) flag = true;
temp = a[temp];
}
if (flag) b[i] = true;
}
f[d[k]] = true;
for (int j = 1; j <= n; j++) {
if (b[j]) continue;
for (int i = n; i >= d[k] + d[j]; i--) {
f[i] |= f[i - d[j]];
}
}
for (int i = 1; i <= n; i++)
if (f[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, a[1000], ai[1000];
bool pos[1000];
vector<int> lens;
int main() {
ios::sync_with_stdio(0);
cin >> n >> x, --x;
memset(ai, -1, sizeof ai);
memset(pos, false, sizeof pos);
for (int i = 0; i < n; ++i) cin >> a[i], --a[i], ai[a[i]] = i;
for (int i = 0; i < n; ++i)
if (ai[i] == -1) {
int curlen = 0, j = i, smart = -1;
do {
++curlen;
if (j == x) smart = curlen;
} while ((j = a[j]) != -1);
if (smart != -1)
pos[curlen - smart] = true;
else
lens.push_back(curlen);
}
for (int i = 0; i < lens.size(); ++i)
for (int j = n - 1; j >= lens[i]; --j) pos[j] |= pos[j - lens[i]];
for (int i = 0; i < n; ++i)
if (pos[i]) cout << (i + 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (1LL << 58);
const bool DEBUG = 0;
const int MAX_LIMIT = 1003;
int color[MAX_LIMIT], pos[MAX_LIMIT], componentSize[MAX_LIMIT];
std::vector<int> adj[MAX_LIMIT];
bool vis[MAX_LIMIT];
int currColor;
int globalColor = 1;
int nodes, nodeId;
set<int> ans;
bool done[MAX_LIMIT][MAX_LIMIT];
int before[MAX_LIMIT];
int dfs(int node, int currRank) {
if (vis[node]) return 0;
vis[node] = 1;
color[node] = currColor;
pos[node] = currRank;
int i, limit = adj[node].size();
if (DEBUG) {
cerr << node << " " << currColor << "\n";
}
int ret = 0;
for (i = 0; i < limit; i++) {
int v = adj[node][i];
ret += dfs(v, currRank + 1);
}
return ret + 1;
}
void rec(int ind, int currSum) {
if (ind == globalColor) {
ans.insert(currSum + pos[nodeId]);
return;
}
if (done[ind][currSum]) return;
done[ind][currSum] = 1;
rec(ind + 1, currSum);
if (ind != color[nodeId]) {
rec(ind + 1, currSum + componentSize[ind]);
}
return;
}
int main() {
int i, j;
scanf("%d", &nodes);
scanf("%d", &nodeId);
for (i = 1; i < nodes + 1; i++) {
int x;
scanf("%d", &x);
adj[x].push_back(i);
before[i] = x;
}
for (i = 1; i < nodes + 1; i++) {
if (before[i] == 0) {
currColor = globalColor;
componentSize[globalColor] = dfs(i, 1);
globalColor++;
}
}
rec(1, 0);
set<int>::iterator itr;
for (itr = ans.begin(); itr != ans.end(); itr++) {
printf("%d\n", *itr);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:100000000")
int mas[1111];
int obr[1111];
vector<int> lines;
int main() {
int n, x;
scanf("%d %d", &n, &x);
for (int i = 1; i <= n; i++) scanf("%d", &mas[i]), obr[mas[i]] = i;
int num = -1;
int bobrlen = 0;
int g = 0;
for (int i = 1; i <= n; i++) {
if (mas[i] == 0) {
int len = 1;
int v = i;
int d = 0;
if (v == x) num = (int)(lines).size(), g = d;
while (obr[v] != 0) {
d++;
v = obr[v];
if (v == x) num = (int)(lines).size(), g = d;
len++;
}
lines.push_back(len);
}
}
bobrlen = lines[num];
swap(lines[num], lines[(int)(lines).size() - 1]);
lines.pop_back();
sort(lines.begin(), lines.end());
bool can[11111];
for (int i = 0; i < 11111; i++) can[i] = false;
can[0] = true;
for (int i = (int)(lines).size() - 1; i >= 0; i--) {
for (int j = 1110; j >= 0; j--) {
if (can[j]) {
can[j + lines[i]] = true;
}
}
}
for (int i = 0; i < 11111; i++) {
if (can[i]) {
printf("%d\n", i + g + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nextnum = 1;
int mynum = 0;
int resultnum = 0;
int check[1100] = {0};
int n, x;
int main() {
int error;
error = 0;
cin >> n >> x;
int input[1100] = {0};
int count[1100] = {0};
bool result[2100] = {0};
void numsearch(int *input, int *check, int x);
for (int i = 0; i < n; i++) {
cin >> input[i];
}
numsearch(input, check, x - 1);
int num(int *input, int *check, int i);
for (int i = 0; i < n; i++) {
if (check[i] == 0) {
check[i] = num(input, check, i);
}
}
for (int i = 1; i < nextnum; i++) {
for (int j = 0; j < n; j++) {
if (check[j] == i) {
count[i]++;
} else {
error++;
}
}
}
count[check[x - 1]] = mynum;
void shukei(int *count, bool *result);
shukei(count, result);
for (int i = 1; i < n + 1; i++) {
if (result[i]) {
cout << i << endl;
}
}
}
int num(int *input, int *check, int i) {
if (input[i] != 0) {
int j = input[i];
return check[i] = num(input, check, j - 1);
} else {
if (check[i] != 0) {
return check[i];
} else {
return check[i] = nextnum++;
}
}
}
void numsearch(int *input, int *check, int x) {
if (input[x] == 0) {
mynum++;
} else {
int j = input[x];
mynum++;
numsearch(input, check, j - 1);
}
}
void shukei(int *count, bool *result) {
result[mynum] = true;
bool cp[2100];
for (int j = 1; j < n + 1; j++) {
cp[j] = result[j];
}
for (int i = 1; i < nextnum; i++) {
if (i != check[x - 1]) {
for (int j = 1; j < n + 1; j++) {
if (cp[j]) {
result[j + count[i]] = true;
}
}
for (int j = 1; j < n + 1; j++) {
cp[j] = result[j];
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 1001;
int n, x, xlast, parent[MAXN];
bool dp[MAXN][MAXN];
vector<int> lasts, sz = {0};
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> x;
int a;
for (int i = 1; i <= n; i++) {
cin >> a;
if (a > 0)
parent[a] = i;
else
lasts.emplace_back(i);
}
for (auto v : lasts) {
int cnt = 0;
bool addChain = true;
for (; v > 0; v = parent[v]) {
cnt++;
if (v == x) xlast = cnt, addChain = false;
}
if (addChain) sz.emplace_back(cnt);
}
int m = sz.size();
m--;
for (int j = 0; j <= m; j++) {
dp[0][j] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[i][j - 1])
dp[i][j] = true;
else if (i >= sz[j] && dp[i - sz[j]][j - 1]) {
dp[i][j] = true;
}
}
}
for (int i = 0; i <= n; i++) {
if (dp[i][m]) {
cout << xlast + i << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int to[2000];
char used[2000];
int a[2000];
int s;
char res[3000];
int calc(int x, char &f) {
f = 0;
int cnt = 1;
if (x == s) f = 1;
while (to[x] != -1) {
++cnt;
x = to[x];
if (x == s) {
f = 1;
cnt = 1;
}
}
return cnt;
}
int main() {
int n, x;
cin >> n >> x;
--x;
s = x;
for (int i = 0; i < n; ++i) to[i] = -1;
for (int i = 0; i < n; ++i) {
cin >> to[i];
--to[i];
if (to[i] >= 0) used[to[i]] = 1;
}
int sl = -1;
int q = 0;
for (int i = 0; i < n; ++i)
if (!used[i]) {
char f;
int len = calc(i, f);
if (f)
sl = len;
else
a[q++] = len;
}
assert(sl != -1);
res[sl] = 1;
for (int i = 0; i < q; ++i) {
for (int j = n; j >= 0; --j)
if (res[j]) res[j + a[i]] = 1;
}
for (int i = 0; i <= n; ++i)
if (res[i]) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int p[N], to[N], n, x, cnt, pos, save;
bool ok, may[N];
vector<int> dif;
void dfs(int v) {
cnt++;
pos++;
if (v == x) {
ok = 1;
save = pos;
}
if (to[v]) dfs(to[v]);
}
int main() {
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i]) to[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (!p[i]) {
cnt = 0;
pos = 0;
ok = 0;
dfs(i);
if (!ok) dif.push_back(cnt);
}
}
may[0] = 1;
for (int i = 0; i < (int)(dif).size(); i++) {
for (int j = N - 1; j >= 0; j--)
if (may[j]) {
if (j + dif[i] < N) may[j + dif[i]] = 1;
}
}
for (int j = 0; j + save < N; j++) {
if (may[j]) cout << j + save << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int x, p;
int a[1000];
int b[1000];
int d[1000];
int dp[1000];
int dfs(int y) {
if (y == x) return -1e9;
if (a[y] == 0) return 1;
return dfs(a[y] - 1) + 1;
}
int dfs2(int y) {
if (y == x) {
if (a[y] == 0) {
p = 1;
} else {
p = dfs2(a[y] - 1) + 1;
}
return p;
}
if (a[y] == 0) return 1;
return dfs2(a[y] - 1) + 1;
}
int main() {
int n, c = 0, i, j;
scanf("%d %d", &n, &x);
x--;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) d[a[i] - 1] = 1;
}
for (i = 0; i < n; i++) {
if (d[i] == 0) {
int y = dfs(i);
if (y >= 0) {
b[c++] = y;
} else {
dfs2(i);
}
}
}
dp[0] = 1;
for (i = 0; i < c; i++) {
for (j = n - 1; j >= 0; j--) {
if (dp[j] == 0) continue;
dp[j + b[i]] = 1;
}
}
for (i = 0; i < n; i++) {
if (dp[i] == 1) printf("%d\n", i + p);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx,avx2")
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 1005;
int n, id, pos, nxt[N], a[N], m;
bool v[N];
bitset<1005> f;
signed main() {
read(n);
read(id);
for (int i = 1, x; i <= n; i++)
if (read(x)) v[i] = 1, nxt[x] = i;
for (int i = 1; i <= n; i++)
if (!v[i]) {
int cnt = 1;
bool flag = 1;
for (int x = i; x && flag; cnt++, x = nxt[x])
if (x == id) {
flag = 0;
pos = cnt;
break;
}
if (flag) a[++m] = cnt - 1;
}
f[0] = 1;
for (int i = 1; i <= m; i++) f |= f << a[i];
for (int i = 0; i + pos <= n; i++)
if (f[i]) write(i + pos), puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, k, l;
long long a[1006], fix[1005], b[1003][1003], c[1003][1003], sh[3000], v[1005];
long long x, y, ra, r;
void go(int x) {
fix[x] = 1;
r++;
int l;
for (l = 1; l <= n; l++) {
if (fix[l] == 0 && b[x][l] == 1) go(l);
}
}
void go1(int y) {
fix[y] = 1;
r++;
int l;
for (l = 1; l <= n; l++) {
if (fix[l] == 0 && b[y][l] == 1 && c[l][y] == 1) go(l);
}
}
int main() {
cin >> n >> x;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[i][a[i]] = 1;
c[a[i]][i] = 1;
b[a[i]][i] = 1;
}
r = 0;
go1(x);
y = r;
go(x);
for (i = 1; i <= n; i++)
if (fix[i] == 0) {
r = 0;
go(i);
ra++;
v[ra] = r;
}
sh[0] = 1;
for (i = 1; i <= ra; i++) {
for (j = n; j >= 0; j--)
if (sh[j] == 1) sh[j + v[i]] = 1;
}
for (i = 0; i <= n; i++)
if (sh[i] == 1) cout << i + y << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000;
int mark[maxn], dp[maxn][maxn], ch[maxn], par[maxn], A[maxn], ans[maxn], x, t;
int K = 0;
void dfs(int u) {
if (u == x) K = 1;
if (mark[u]) return;
t++;
mark[u] = 1;
if (par[u]) dfs(par[u]);
if (ch[u]) dfs(ch[u]);
}
int ted(int u) {
if (!par[u]) return 0;
return ted(par[u]) + 1;
}
int main() {
int n;
cin >> n >> x;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
cin >> par[i];
ch[par[i]] = i;
dp[0][i] = 1;
}
for (int i = 1; i <= n; i++)
if (!mark[i]) {
K = 0, t = 0, dfs(i);
if (!K) A[i] = t;
}
t = 0;
t = ted(x);
ans[0] = 1;
for (int i = 1; i <= n; i++) {
for (int s = 1; s <= n - t - 1; s++) {
dp[s][i] = ((s - A[i] >= 0 ? dp[s - A[i]][i - 1] : 0) || dp[s][i - 1]);
if (dp[s][i]) ans[s] = 1;
}
}
for (int i = 0; i <= n; i++)
if (ans[i]) cout << 1 + i + t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111;
int num[maxn];
int tot;
int head[maxn];
int vis[maxn];
int sum;
int dp[maxn][maxn];
int tt;
int pos;
int tot2;
int head2[maxn];
void init() {
tot = 0;
memset(head, -1, sizeof(head));
tot2 = 0;
memset(head2, -1, sizeof(head2));
memset(vis, 0, sizeof(vis));
tt = 0;
}
struct {
int v, next;
} edge[maxn * maxn], edge2[maxn * maxn];
void add(int u, int v) {
edge[tot].v = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void dfs(int u) {
vis[u] = 1;
sum++;
int i, v;
for (i = head[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (!vis[v]) dfs(v);
}
}
void add2(int u, int v) {
edge2[tot2].v = v;
edge2[tot2].next = head2[u];
head2[u] = tot2++;
}
void dfs2(int u) {
sum++;
int i, v;
for (i = head2[u]; i != -1; i = edge2[i].next) {
v = edge2[i].v;
dfs2(v);
}
}
int main() {
int i, j, n, m;
int a;
while (scanf("%d%d", &n, &m) != EOF) {
init();
tt = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
if (a) {
add(i, a);
add(a, i);
add2(i, a);
}
}
sum = 0;
dfs(m);
sum = 0;
dfs2(m);
pos = sum;
for (i = 1; i <= n; i++) {
sum = 0;
if (!vis[i]) {
dfs(i);
num[++tt] = sum;
}
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j <= n; j++) {
dp[i][j] = dp[i - 1][j];
if (!dp[i][j] && j - num[i] >= 0) {
dp[i][j] = dp[i - 1][j - num[i]];
}
}
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (dp[j][i] == 1) {
printf("%d\n", i + pos);
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 1e17;
int main() {
long long int n, x, a;
cin >> n >> x;
x--;
vector<long long int> op(n, -1), an(n, -1);
vector<long long int> ch(n, 0);
vector<long long int> used(n, 0);
for (long long int i = 0; i < n; i++) {
cin >> a;
if (!a)
ch[i] = 1;
else {
a--;
op[i] = a;
an[a] = i;
}
}
long long int num = 1;
while (!ch[x]) {
num++;
x = op[x];
}
used[x]++;
vector<long long int> numb;
for (long long int i = 0; i < n; i++) {
if (ch[i] && !used[i]) {
used[i]++;
long long int temp = 1;
x = i;
while (an[x] != -1) {
temp++;
x = an[x];
}
numb.push_back(temp);
}
}
sort(numb.begin(), numb.end());
vector<long long int> can(n + 1, 0);
can[num] = 1;
for (long long int i = 0; i < numb.size(); i++) {
vector<long long int> newo = can;
for (long long int j = 0; j <= n; j++) {
if (can[j]) newo[j + numb[i]]++;
}
can = newo;
}
for (long long int i = 0; i <= n; i++) {
if (can[i]) cout << i << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e3 + 10;
bool f[2][mx];
int nxt[mx], bef[mx];
int d[mx];
int main() {
int n, x, u;
scanf("%d %d", &n, &x);
memset(bef, -1, sizeof bef);
memset(nxt, -1, sizeof nxt);
for (int i = 1; i <= n; i++) {
scanf("%d", &u);
if (u != 0) {
nxt[i] = u;
bef[u] = i;
}
}
int lx = 0;
int c = 0;
for (int i = 1; i <= n; i++) {
if (bef[i] == -1) {
u = i;
int len = 0;
int lenx = 0;
while (u != -1) {
if (u == x || lenx > 0) lenx++;
len++;
u = nxt[u];
}
if (lenx == 0)
d[c++] = len;
else
lx = lenx;
}
}
int rw = 0;
f[0][0] = true;
for (int i = 0; i < c; i++) {
rw ^= 1;
for (int s = 0; s < mx; s++) {
f[rw][s] = f[rw ^ 1][s];
if (s >= d[i]) f[rw][s] |= f[rw ^ 1][s - d[i]];
}
}
vector<int> ans;
for (int s = 0; s < n; s++)
if (f[rw][s]) printf("%d\n", s + lx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maz[1005][1005];
bool vist[5005];
vector<int> vec, ans;
int block[1005], f[1500];
int n, x;
int pos, numb;
bool flag;
int tot;
void dfs(int bb, int cur) {
vist[cur] = 1;
tot++;
if (cur == x) {
pos = tot;
numb = bb;
flag = 1;
}
for (int i = (1); i <= (n); i++) {
if (!vist[i] && maz[cur][i]) {
dfs(bb, i);
}
}
}
int main() {
memset(maz, 0, sizeof(maz));
memset(vist, 0, sizeof(vist));
memset(block, 0, sizeof(block));
vec.clear();
int a;
scanf("%d%d", &n, &x);
for (int i = (1); i <= (n); i++) {
scanf("%d", &a);
if (a == 0)
vec.push_back(i);
else
maz[a][i] = 1;
}
int sz = vec.size();
for (int i = 0; i < sz; i++) {
flag = 0;
tot = 0;
dfs(i, vec[i]);
if (!flag) block[i] = tot;
}
sort(block, block + sz);
memset(f, 0, sizeof(f));
for (int i = (1); i <= (sz - 1); i++) {
for (int j = n; j >= block[i]; j--) {
if (f[j] < f[j - block[i]] + block[i]) f[j] = f[j - block[i]] + block[i];
}
}
for (int i = (0); i <= (n); i++) {
if (f[i] == i) {
printf("%d\n", pos + i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
int getint() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
return x;
}
int n, x, settp, pos, tag;
int p[1010], son[1010], set[1010], dp[1010];
void init() {
n = getint();
x = getint();
dp[0] = 1;
for (int i = 1; i <= n; i++) {
p[i] = getint();
if (p[i]) son[p[i]] = i;
}
}
void run(int idx, int no) {
if (idx == x) {
tag = 1;
pos = no;
}
if (tag) return;
if (son[idx])
run(son[idx], no + 1);
else
set[settp++] = no;
}
void process() {
for (int i = 1; i <= n; i++)
if (!p[i]) {
tag = 0;
run(i, 1);
}
for (int i = 0; i < settp; i++)
for (int j = n; j >= set[i]; j--)
if (dp[j - set[i]]) dp[j] = 1;
for (int i = 0; i + pos <= n; i++)
if (dp[i]) printf("%d\n", i + pos);
}
int main() {
init();
process();
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1000000];
int rk[1000000], fa[1000000], cnt[1000000];
bool vis[1000000];
int n, x, y;
void init() {
for (int i = 0; i <= n; i++) fa[i] = i, rk[i] = 0;
}
int find(int a) {
if (fa[a] != a) {
int t = fa[a];
fa[a] = find(fa[a]);
rk[a] += rk[t];
}
return fa[a];
}
int main() {
scanf("%d%d", &n, &x);
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &y);
if (y != 0) {
fa[i] = y;
rk[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
int fa1 = find(i);
cnt[fa1]++;
}
int fax = find(x);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (i != fax && cnt[i]) {
for (int j = n + 1; j >= cnt[i]; j--)
if (dp[j - cnt[i]]) dp[j] = 1;
}
}
for (int i = 0; i <= n; i++)
if (dp[i]) {
printf("%d\n", i + rk[x] + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& second) { return '"' + second + '"'; }
string to_string(char c) {
string second;
second += c;
return second;
}
string to_string(const char* second) { return to_string((string)second); }
string to_string(bool b) { return (b ? "1" : "0"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (long long i = 0; i < static_cast<long long>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << "\n"; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
void Clearing_out() { return; }
template <typename Head, typename... Tail>
void Clearing_out(Head& H, Tail&... T) {
H.clear();
Clearing_out(T...);
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void time() {
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
}
void hi() {
static long long i = 0;
cerr << "Check Point : " << ++i << "\n";
return;
}
long long stoi1(string str) {
bool negative;
if (str[0] == '-') {
negative = true;
str = str.substr(1);
} else {
negative = false;
}
long long n = str.length();
long long number = 0;
long long pos = 1;
for (long long i = n - 1; i >= 0; i--) {
number = number + (str[i] - '0') * pos;
pos = pos * 10;
}
if (negative) number = -number;
return number;
}
long long power(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n % 2 != 0) {
res = res * a;
n--;
} else if (n % 2 == 0) {
a = a * a;
n = n / 2;
}
}
return res;
}
pair<long long, long long> min(vector<long long> v, bool first = true) {
bool last = !first;
long long mini = 1000000000000000007;
long long mini_index = -1;
long long n = (long long)v.size();
for (long long i = 0; i < n; i++) {
if ((mini > v[i] && first) || (mini >= v[i] && last)) {
mini = v[i];
mini_index = i;
}
}
return {mini_index, mini};
}
pair<long long, long long> max(vector<long long> v, bool first = true) {
bool last = !first;
long long maxi = -1000000000000000007;
long long maxi_index = -1;
long long n = (long long)v.size();
for (long long i = 0; i < n; i++) {
if ((maxi < v[i] && first) || (maxi <= v[i] && last)) {
maxi = v[i];
maxi_index = i;
}
}
return {maxi_index, maxi};
}
long long sum(vector<long long> v, long long start = 0, long long last = -1) {
if (last == -1) last = (long long)v.size() - 1;
long long ans = 0;
for (long long i = start; i <= last; i++) {
ans = ans + v[i];
}
return ans;
}
long long len(vector<long long> v) { return (long long)v.size(); }
long long rand(long long a, long long b) { return a + rand() % (b - a + 1); }
vector<long long> generate_random_vector() {
vector<long long> v;
long long n = rand(10, 20);
set<long long> used;
for (long long i = 0; i < n; ++i) {
long long x;
do {
x = rand(10, 1000);
} while (used.count(x));
v.push_back(x);
used.insert(x);
}
return v;
}
const long long max_size = 1e6 + 10000;
const double eps = 1e-18;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> v(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> v[i];
}
vector<long long> in(n + 1);
for (long long i = 1; i <= n; i++) {
bool found = false;
for (long long j = 1; j <= n; j++) {
if (v[j] == i) {
found = true;
break;
}
}
if (found) {
in[i] = 1;
}
}
long long start = x;
long long length = 0;
while (start != 0) {
length++;
start = v[start];
}
long long p = length;
vector<long long> v_length;
for (long long i = 1; i <= n; i++) {
if (in[i] == 0) {
long long start = i;
long long length = 0;
bool smart = false;
while (start != 0) {
length++;
if (start == x) smart = true;
start = v[start];
}
if (!smart) v_length.push_back(length);
}
}
long long v_size = v_length.size();
sort(v_length.begin(), v_length.end());
cerr << "["
<< "v_length"
<< "]:",
debug_out(v_length);
vector<vector<long long>> matrix(v_size, vector<long long>(n + 1));
if (v_length.size() == 0) {
cout << p << "\n";
continue;
}
matrix[0][v_length[0]] = 1;
matrix[0][0] = 1;
for (long long i = 1; i < v_size; i++) {
for (long long j = 0; j <= n; j++) {
if (matrix[i - 1][j] == 1) {
matrix[i][j] = 1;
} else {
if (j >= v_length[i]) {
matrix[i][j] = matrix[i - 1][j - v_length[i]];
} else {
matrix[i][j] = 0;
}
}
}
}
vector<long long> final(n + 1);
for (long long i = 1; i <= n; i++) {
if (matrix[v_size - 1][i] == 1 && i + p <= n) {
final[i + p] = 1;
}
}
cout << p << "\n";
for (long long i = 1; i <= n; i++) {
if (final[i] == 1) {
cout << i << "\n";
}
}
}
time();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 11111;
int h[N], f[N], opt[N], a[N], b[N], c[N], d[N];
int n, m, i, j, k, x, ch;
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) f[i] = i;
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (b[i]) f[find(i)] = f[find(b[i])];
}
for (i = 1; i <= n; i++)
if (f[find(m)] != i) {
int cnt = 0;
for (j = 1; j <= n; j++)
if (f[find(j)] == i) cnt++;
if (cnt) a[++ch] = cnt;
}
opt[1] = 1;
for (i = 1; i <= ch; i++)
for (j = n; j >= a[i]; j--) opt[j] |= opt[j - a[i]];
int cnt = 0, top = 0;
for (i = 1; i <= n; i++)
if (f[find(i)] == f[find(m)]) c[++cnt] = i;
queue<int> q;
for (i = 1; i <= cnt; i++)
if (!b[c[i]]) {
d[++top] = c[i];
q.push(c[i]);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (i = 1; i <= cnt; i++)
if (b[c[i]] == u) {
int v = c[i];
b[v] = 0;
d[++top] = v;
q.push(v);
}
}
for (x = 1; x <= top; x++)
if (d[x] == m) break;
x--;
for (i = 1; i <= n - cnt + 1; i++)
if (opt[i]) printf("%d\n", i + x);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const int maxn = 2e5 + 100;
const int base = 29;
const int mod = 1e9 + 7;
const int INF = 2e9 + 100;
int nxt[maxn];
int sz[maxn];
int deg[maxn];
bool mark[maxn];
bool dp[maxn];
bool dp2[maxn];
inline int root(int x) { return (nxt[x] == 0 ? x : nxt[x] = root(nxt[x])); }
inline void dfs(int v) {
mark[v] = true;
sz[v] = 1;
if (nxt[v] == 0) return;
int u = nxt[v];
if (mark[u])
sz[v] += sz[u];
else {
dfs(u);
sz[v] += sz[u];
}
}
int32_t main() {
int n = in(), id = in();
for (int i = 1; i <= n; i++) nxt[i] = in(), deg[nxt[i]]++;
for (int i = 1; i <= n; i++) {
if (!mark[i]) dfs(i);
}
vector<int> vc;
for (int i = 1; i <= n; i++)
if (deg[i] == 0 && root(i) != root(id)) vc.push_back(sz[i]);
dp[0] = true;
for (int i = 0; i < vc.size(); i++) {
for (int j = 0; j + vc[i] <= 1000; j++) dp2[j + vc[i]] |= dp[j];
for (int j = 0; j <= 1000; j++) dp[j] |= dp2[j], dp2[j] = false;
}
for (int x = 0; x <= 1000; x++) {
if (dp[x]) {
cout << x + sz[id] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
template <class T>
void read(T& container) {
for (typename T::value_type& x : container) cin >> x;
}
template <class T>
void print(T& container, const char separator = ' ') {
for (typename T::value_type& x : container) cout << x << separator;
}
void openFiles(const char* in, const char* out) {
freopen(in, "r", stdin);
freopen(out, "w", stdout);
}
int n, x;
vector<int> v;
const int maxn = 1100;
bool used[maxn];
bool in[maxn];
bool can[2 * maxn];
vector<int> sz;
void run() {
cin >> n >> x;
--x;
v.resize(n);
read(v);
for (int x : v) {
in[x - 1] = 1;
}
int add;
for (int i = 0; i < n; ++i)
if (!used[i] && !in[i]) {
bool p = 0;
int cc = 0;
int tmp = 0, j;
for (j = i; v[j] != 0; j = v[j] - 1) {
if (j == x) {
p = 1;
cc = tmp;
}
++tmp;
}
if (j == x) {
p = 1;
cc = tmp;
}
if (!p)
sz.push_back(tmp + 1);
else
add = tmp - cc + 1;
}
can[0] = 1;
for (int x : sz)
for (int i = n - 1; i >= 0; --i)
if (can[i]) can[i + x] = 1;
for (int i = 0; i < n; ++i)
if (can[i]) cout << i + add << endl;
}
} // namespace
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1111];
class DSU {
private:
int* rk;
int* p;
public:
DSU(size_t n) {
rk = new int[n];
p = new int[n];
for (size_t i = 0; i < n; ++i) p[i] = i, rk[i] = 1;
}
~DSU() {
delete[] rk;
delete[] p;
}
inline int get(int v) {
int cur = v;
while (cur != p[cur]) cur = p[cur];
int ret = cur;
cur = v;
while (cur != p[cur]) v = p[cur], p[cur] = ret, cur = v;
return ret;
}
int getrk(int v) { return rk[get(v)]; }
void unite(int a, int b) {
a = get(a), b = get(b);
if (a == b) return;
if (rk[a] < rk[b]) swap(a, b);
p[b] = a;
rk[a] += rk[b];
}
};
int sum[1001][1111];
vector<int> pos;
bool subsum(int i, int j) {
if (j == 0) return true;
if (j > 1000 || j < 0) return false;
if (sum[i][j] == 2)
return true;
else if (sum[i][j] == 1)
return false;
if (i == 0) {
sum[0][j] = (pos[0] == j) ? 2 : 1;
} else {
sum[i][j] =
(subsum(i - 1, j) || (pos[i] == j) || subsum(i - 1, j - pos[i])) + 1;
}
return sum[i][j] == 2;
}
int main() {
cin.sync_with_stdio(false);
int i, n, x;
cin >> n >> x;
for (i = 0; i < (n); ++i) cin >> a[i + 1];
DSU d(n + 1);
for (i = 1; i <= n; ++i) {
if (a[i] != 0) d.unite(i, a[i]);
}
set<int> dif;
for (i = 1; i <= n; ++i) dif.insert(d.get(i));
dif.erase(dif.find(d.get(x)));
int posx = 0;
while (x != 0) x = a[x], posx++;
for (set<int>::iterator it = dif.begin(); it != dif.end(); ++it)
pos.push_back(d.getrk(*it));
if (pos.size() == 0) {
cout << posx << endl;
return 0;
}
for (i = 0; i <= n; ++i)
if (subsum(pos.size() - 1, i)) cout << i + posx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline string toString(T a) {
ostringstream os("");
os << a;
return os.str();
}
template <typename T>
inline long long toLong(T a) {
long long res;
istringstream os(a);
os >> res;
return res;
}
template <typename T>
inline T SQ(T a) {
return a * a;
}
template <typename T>
inline T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline unsigned long long bigmod(T a, T b, T m) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return S(bigmod(a, b / 2, m)) % m;
else
return (a % m * bigmod(a, b - 1, m)) % m;
}
template <typename T>
inline vector<string> parse(T str) {
vector<string> res;
string s;
istringstream os(str);
while (os >> s) res.push_back(s);
return res;
}
template <typename T>
inline unsigned long long dist(T A, T B) {
unsigned long long res =
(A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);
return res;
}
template <typename T>
inline double cosAngle(T a, T b, T c) {
double res = a * a + b * b - c * c;
res = res / (2 * a * b);
res = acos(res);
return res;
}
template <typename T>
inline T power(T base, int po) {
T res = 1;
if (base == 0) return 0;
for (int i = (0); i < (po); i++) res *= base;
return res;
}
template <typename T>
inline bool isOn(T mask, T pos) {
return mask & (1 << pos);
}
template <typename T>
inline int Off(T mask, T pos) {
return mask ^ (1 << pos);
}
template <typename T>
inline int On(T mask, T pos) {
return mask | (1 << pos);
}
int arr[1005];
int frn[1005], bck[1005];
bool vis[1005];
bool st;
int pos;
int dp[2005];
int main() {
int i, j, k;
int x, y;
int n;
cin >> n >> pos;
for (int i = (1); i < (n + 1); i++) {
cin >> x;
if (x) frn[i] = x, bck[x] = i;
}
memset(dp, 0, sizeof dp);
dp[0] = 1;
for (int i = pos; i <= pos; i++) {
if (vis[i]) continue;
int cur = 0;
x = i;
while (x) {
vis[x] = 1;
cur++;
x = frn[x];
}
y = cur;
x = bck[i];
while (x) {
vis[x] = 1;
x = bck[x];
}
}
vector<int> v;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
int cur = 0;
x = i;
while (x) {
vis[x] = 1;
cur++;
x = frn[x];
}
x = bck[i];
while (x) {
vis[x] = 1;
cur++;
x = bck[x];
}
v.push_back(cur);
}
int Sz = v.size();
dp[y] = 1;
for (int i = (0); i < (Sz); i++) {
for (j = n; j >= 1; j--) {
if (dp[j]) dp[j + v[i]] = 1;
}
}
for (int i = (1); i < (n + 1); i++) {
if (dp[i]) cout << i << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ((1 << 30) - 1);
const long long linf = ((1ll << 62) - 1);
const int cmax = 1001;
int n, x;
int a[cmax];
bool u[cmax];
vector<vector<int> > groups;
vector<int> ts;
void topSort(int v) {
if (u[v]) return;
u[v] = true;
if (a[v] != -1) topSort(a[v]);
ts.push_back(v);
}
void go(int v, vector<int> &c) {
u[v] = true;
c.push_back(v);
if (a[v] != -1) go(a[v], c);
}
int dp[cmax][cmax];
int main() {
int index;
assert(scanf("%d%d", &n, &x)), --x;
for (int i = 0; i < n; i++) assert(scanf("%d", &a[i])), --a[i];
for (int i = 0; i < n; i++) topSort(i);
memset(u, 0, sizeof(bool) * n);
reverse((ts).begin(), (ts).end());
for (int i = 0; i < n; i++)
if (!u[ts[i]])
groups.push_back(vector<int>()),
go(ts[i], groups[((int)(groups).size()) - 1]);
for (int i = 0; i < ((int)(groups).size()); i++) {
int pos =
find((groups[i]).begin(), (groups[i]).end(), x) - groups[i].begin();
if (pos != ((int)(groups[i]).size())) {
groups.erase(groups.begin() + i);
index = pos;
break;
}
}
dp[0][0] = 1;
for (int i = 0; i < ((int)(groups).size()); i++)
for (int j = 0; j < n; j++)
if (dp[i][j])
dp[i + 1][j] = true, dp[i + 1][j + ((int)(groups[i]).size())] = true;
for (int i = n - 1; i >= 0; i--)
if (dp[((int)(groups).size())][i]) cout << n - i - index << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sa[1007], n, t, x, d[1007], s;
bool f[1007], c[1007];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) {
scanf("%d", &t), sa[t] = i;
if (t == 0) c[i] = 1;
}
for (int i = 1; i <= n; ++i) {
if (!c[i]) continue;
int kt = 1, t2 = 1, j = i;
while (j) {
if (j == x) kt = 0, t = t2;
j = sa[j], ++t2;
}
if (kt) d[++s] = t2 - 1;
}
f[0] = 1;
for (int i = 1; i <= s; ++i)
for (int j = 1000; j >= d[i]; --j)
if (f[j - d[i]]) f[j] = 1;
for (int i = 0; i + t <= n; ++i)
if (f[i]) printf("%d\n", t + i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1100][1100];
int a[1100], cnt;
void gao(int n) {
int i, j;
dp[0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j <= 1000; j++)
if (dp[i][j]) {
if (j + a[i + 1] <= 1000) dp[i + 1][j + a[i + 1]] = 1;
dp[i + 1][j] = 1;
}
}
}
int fa[1100];
int you[1100];
void ca(int n, int x) {
int i = 1, is = 0;
if (n == x) is = 1;
while (fa[n]) {
i++, n = fa[n];
if (n == x) is = 1;
}
if (!is) a[++cnt] = i;
}
int main() {
int n, x, i, j, k;
scanf("%d", &n);
scanf("%d", &x);
for (i = 1; i <= n; i++) {
scanf("%d", &j);
you[j] = 1;
fa[i] = j;
}
for (i = 1; i <= n; i++)
if (!you[i]) ca(i, x);
gao(cnt);
int ans = 1;
while (fa[x]) ans++, x = fa[x];
for (i = 0; i <= 1000; i++)
if (dp[cnt][i]) printf("%d\n", ans + i);
}
|
#include <bits/stdc++.h>
int n, m, up, spe, sp;
int a[1010];
int s[1010];
int f[1010];
int v[1010];
int dp[3010];
int findset(int x) {
if (x == f[x]) return x;
f[x] = findset(f[x]);
return f[x];
}
inline void init() {
int i, fx, fy;
scanf("%d%d", &n, &m);
spe = 0;
sp = m;
for (i = 1; i <= n; i++) {
f[i] = i;
s[i] = 1;
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
if (a[i] == 0) continue;
fx = findset(a[i]);
fy = findset(i);
if (fy == sp) spe += s[fx];
if (a[i] == sp) sp = fy;
s[fy] += s[fx];
f[fx] = fy;
}
up = 0;
for (i = 1; i <= n; i++) {
fx = findset(i);
if (s[fx] && sp != fx) {
up++;
v[up] = s[fx];
s[fx] = 0;
}
}
}
inline void work() {
int i, j;
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (i = 1; i <= up; i++)
for (j = n; j >= v[i]; j--)
if (dp[j - v[i]]) dp[j] = 1;
spe++;
for (i = 0; i <= n - spe; i++)
if (dp[i]) printf("%d\n", i + spe);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[111111], b[111111], c[1111];
void po(int p) {
if (a[p] == 0)
b[p]++;
else
po(a[p]);
}
int main() {
int z = 0, k, i, j, x, y;
string s1, s2;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) po(i);
x = 1;
while (a[m]) {
m = a[m];
x++;
}
c[0] = 1;
for (i = 1; i <= n; i++)
if (b[i] && i != m) {
for (j = n; j >= 0; j--)
if (c[j]) c[j + b[i]] = 1;
}
for (i = 0; i <= n; i++)
if (c[i]) cout << i + x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int nn;
int leads[N];
int follows[N];
bool visited[N];
int curr;
for (nn = 0; nn < N; ++nn) {
leads[nn] = follows[nn] = -1;
visited[nn] = false;
}
for (nn = 0; nn < N; ++nn) {
cin >> curr;
if (curr == 0) continue;
leads[nn] = (curr - 1);
follows[curr - 1] = nn;
}
vector<deque<int> *> streams;
map<int, deque<int> *> streamMap;
int next;
for (nn = 0; nn < N; ++nn) {
if (visited[nn]) continue;
deque<int> *currdeq = new deque<int>;
streams.push_back(currdeq);
currdeq->push_back(nn);
visited[nn] = true;
streamMap[nn] = currdeq;
next = leads[nn];
while (next >= 0) {
currdeq->push_front(next);
visited[next] = true;
streamMap[next] = currdeq;
next = leads[next];
}
next = follows[nn];
while (next >= 0) {
currdeq->push_back(next);
visited[next] = true;
streamMap[next] = currdeq;
next = follows[next];
}
}
int offset = 0;
deque<int> *myDeq = streamMap[X - 1];
deque<int>::iterator dqi = myDeq->begin(), dqe = myDeq->end();
for (; dqi != dqe; ++dqi) {
++offset;
if ((*dqi) == X - 1) break;
}
set<int> possibilities;
possibilities.insert(offset);
vector<deque<int> *>::iterator svi, sve;
svi = streams.begin();
sve = streams.end();
vector<int> deqszs;
for (; svi != sve; ++svi) {
if ((*svi) == myDeq) continue;
deqszs.push_back((*svi)->size());
}
sort(deqszs.begin(), deqszs.end());
vector<int>::iterator dsi = deqszs.begin(), dse = deqszs.end();
set<int>::iterator psi, pse;
int currDS;
for (; dsi != dse; ++dsi) {
currDS = *dsi;
set<int> newPosss;
for (psi = possibilities.begin(), pse = possibilities.end(); psi != pse;
++psi) {
newPosss.insert((*psi) + currDS);
}
possibilities.insert(newPosss.begin(), newPosss.end());
}
psi = possibilities.begin();
pse = possibilities.end();
for (; psi != pse; ++psi) {
cout << *psi << endl;
}
svi = streams.begin();
sve = streams.end();
for (; svi != sve; ++svi) {
delete *svi;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
vector<vector<int> > g1;
int n;
int ver[1003];
int coun;
int coun2[1003];
bool flag[1003];
int coun3;
void dfs(int x) {
int i;
coun2[coun]++;
ver[x] = coun;
flag[x] = true;
for (i = 0; i < g[x].size(); i++)
if (!flag[g[x][i]]) dfs(g[x][i]);
}
void dfs2(int x) {
coun3++;
if ((int)g1[x].size() > 0) dfs2(g1[x][0]);
}
int main() {
int i, j;
int x, y;
scanf("%d %d", &n, &x);
g1.resize(n);
g.resize(n);
x--;
for (i = 0; i < n; i++) {
scanf("%d", &y);
if (y > 0 && y - 1 != i) {
y--;
g[i].push_back(y);
g[y].push_back(i);
g1[i].push_back(y);
}
}
for (i = 0; i < n; i++)
if (!flag[i]) {
dfs(i);
coun++;
}
dfs2(x);
int dp[1003];
for (i = 1; i < 1000; i++) dp[i] = 0;
dp[0] = 1;
for (i = 0; i < coun; i++) {
if (ver[x] != i)
for (j = 999; j > coun2[i] - 1; j--) dp[j] |= dp[j - coun2[i]];
}
for (i = 0; i < 1000; i++)
if (dp[i] > 0) printf("%d\n", i + coun3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const oo = 1e9, bound = 3e6 + 1, mod = oo + 7, N = 2e5 + 1, CON = 30000001;
long long const OO = 1e18;
int n, x, nxt[1001], in[1001], dp[1001][1001];
vector<int> con;
int go(int u, bool care) {
int ret = 1;
if (u == x && care) return 0;
while (nxt[u] != -1) {
if (u == x && care) return 0;
u = nxt[u], ret++;
}
if (u == x && care) return 0;
return ret;
}
int rec(int idx, int pos) {
int &ret = dp[idx][pos];
if (ret != -1) return ret;
if (idx == (int)con.size()) return ret = pos == 0;
if (pos == 0) return ret = 1;
int r1 = 0, r2 = 0;
if (pos - con[idx] >= 0) r1 = rec(idx + 1, pos - con[idx]);
r2 = rec(idx + 1, pos);
return ret = r1 || r2;
}
int main() {
memset(nxt, -1, sizeof nxt);
memset(dp, -1, sizeof dp);
cin >> n >> x;
x--;
for (int(i) = 0; (i) < (n); (i)++) {
cin >> nxt[i];
in[--nxt[i]]++;
}
for (int(i) = 0; (i) < (n); (i)++)
if (!in[i]) {
int op = go(i, 1);
if (op) con.push_back(op);
}
int my = go(x, 0);
set<int> res;
res.insert(my);
for (int(i) = 1; (i) <= (n); (i)++)
if (i > my && rec(0, i - my)) res.insert(i);
for (auto a : res) cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
int a[1005];
bool tail[1005];
int main() {
while (scanf("%d%d", &n, &x) != EOF) {
--x;
for (int i = 0; i < (n); ++i) scanf("%d", &a[i]), --a[i];
for (int i = 0; i < (n); ++i) tail[i] = true;
for (int i = 0; i < (n); ++i)
if (a[i] != -1) tail[a[i]] = false;
vector<int> cnt;
for (int i = 0; i < (n); ++i)
if (tail[i]) {
int c = 0, k;
for (k = i; k != -1; k = a[k]) {
if (k == x) break;
++c;
}
if (k == -1) cnt.push_back(c);
}
int base = 0;
for (int k = x; k != -1; k = a[k]) ++base;
set<int> dp1, dp2;
dp1.insert(0);
for (int i = 0; i < (((int)cnt.size())); ++i) {
dp2 = dp1;
for (set<int>::iterator it = dp1.begin(); it != dp1.end(); ++it) {
dp2.insert(*it + cnt[i]);
}
dp1 = dp2;
}
for (set<int>::iterator it = dp1.begin(); it != dp1.end(); ++it) {
printf("%d\n", base + *it);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.0);
bool isSubsetSum(vector<int> set, int n, int sum) {
bool subset[n + 1][sum + 1];
for (int i = 0; i <= n; i++) subset[i][0] = true;
for (int i = 1; i <= sum; i++) subset[0][i] = false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
if (j < set[i - 1]) subset[i][j] = subset[i - 1][j];
if (j >= set[i - 1])
subset[i][j] = subset[i - 1][j] || subset[i - 1][j - set[i - 1]];
}
}
return subset[n][sum];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x, t;
cin >> n >> x;
vector<pair<int, int> > v(n);
vector<int> s;
for (int i = 0; i < n; i++) v[i].second = -1;
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].first--;
if (v[i].first != -1) v[v[i].first].second = i;
}
int cnt, par;
for (int i = 0; i < n; i++) {
if (i == x - 1) continue;
if (v[i].second == -1) {
bool kp = false;
cnt = 1;
par = v[i].first;
while (par != -1) {
if (par == x - 1) kp = 1;
cnt++;
par = v[par].first;
}
if (!kp) s.push_back(cnt);
}
}
sort(s.begin(), s.end());
int p = 0;
par = x - 1;
while (par != -1) {
p++;
par = v[par].first;
}
vector<int> ans;
ans.push_back(p);
for (int i = p + 1; i <= n; i++) {
if (isSubsetSum(s, s.size(), i - p)) ans.push_back(i);
}
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int inf = 10000000;
int g[1005];
bool vis[1005];
vector<int> v, vv;
int cou;
int x, n;
bool gotit;
bool res[1005];
void dfs(int u) {
cou++;
if (x == u) {
gotit = 1;
return;
}
if (g[u] == -1) return;
dfs(g[u]);
}
int main() {
cin >> n >> x;
x--;
memset((g), (-1), sizeof(g));
int a;
for (int i = 0; i < (n); i++) {
scanf("%d", &a);
if (!a)
v.push_back(i);
else {
a--;
g[a] = i;
}
}
int mysize;
for (int i = 0; i < (((int)(v).size())); i++) {
cou = 0;
gotit = 0;
dfs(v[i]);
if (gotit)
mysize = cou;
else
vv.push_back(cou);
}
res[0] = 1;
for (int i = 0; i < (((int)(vv).size())); i++)
for (int j = n; j >= 0; j--) {
int t = vv[i];
if (j + t > n) continue;
res[j + t] |= res[j];
}
for (int i = 0; i < (n + 1); i++)
if (res[i]) printf("%d\n", i + mysize);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.