text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int n, x, a[1024], b[1024], v[1024] = {1};
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), ++b[a[i]];
int t = 0;
for (int i = 1; i <= n; ++i)
if (!b[i]) {
int z = 0, f = 0;
for (int j = i; j > 0; j = a[j], ++z)
if (f |= j == x) ++t;
if (!f)
for (int j = n; j >= z; --j) v[j] |= v[j - z];
}
for (int i = 0; i < n; ++i)
if (v[i]) printf("%d\n", i + t);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1010;
long long n, k, a[N], dp[N][N], jolo = 1;
vector<long long> g[N], b;
vector<vector<long long> > comps;
vector<bool> visited(N, 0);
void dfs(long long v) {
visited[v] = true;
comps.back().push_back(v);
for (auto u : g[v]) {
if (!visited[u]) {
dfs(u);
}
}
}
long long solve(long long n, long long i) {
if (n < 0) {
return 0;
}
if (n == 0) {
return dp[n][i] = 1;
}
if (i == 0) {
return dp[n][i] = (n == b[0]);
}
if (dp[n][i] != -1) {
return dp[n][i];
}
return dp[n][i] = solve(n, i - 1) | solve(n - b[i], i - 1);
}
signed main() {
ios::sync_with_stdio(false);
memset(dp, -1, sizeof dp);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != 0) {
g[i].push_back(a[i]);
g[a[i]].push_back(i);
}
}
comps.push_back({});
dfs(k);
for (long long i = 1; i <= n; i++) {
if (!visited[i]) {
comps.push_back({});
dfs(i);
}
}
long long tmp = k;
while (a[tmp] != 0) {
jolo++;
tmp = a[tmp];
}
long long mx = 0;
for (long long i = 1; i < (long long)(comps.size()); i++) {
mx += (long long)(comps[i].size());
b.push_back((long long)(comps[i].size()));
}
sort(b.begin(), b.end());
for (long long i = 0; i <= mx; i++) {
if (solve(i, (long long)(b.size()) - 1)) {
cout << jolo + i << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1003;
int to[maxn], from[maxn];
int a[maxn];
struct node {
int h, size;
} p[maxn];
int f;
int tot;
int dp[maxn];
int main() {
int i, j;
int n, x;
bool flag = 0;
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i]) {
flag = 1;
from[i] = a[i];
to[a[i]] = i;
}
}
if (!flag) {
for (i = 1; i <= n; i++) printf("%d\n", i);
return 0;
}
int cnt = 0;
for (i = 1; i <= n; i++) {
if (!from[i]) {
p[++tot].h = i;
int c = 1;
j = i;
if (j == x) {
cnt = 1;
f = tot;
}
bool g = 0;
while (to[j]) {
j = to[j];
if (j == x) {
g = 1;
}
c++;
}
p[tot].size = c;
if (g) {
f = tot;
j = i;
c = 1;
while (to[j]) {
j = to[j];
if (j == x) cnt = c + 1;
c++;
}
}
}
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (i = 1; i <= tot; i++)
if (i != f) {
int size = p[i].size;
for (j = n; j >= size; j--)
if (dp[j - size]) dp[j] = 1;
}
vector<int> ans;
for (i = 0; i <= n; i++)
if (dp[i]) ans.push_back(i + cnt);
sort(ans.begin(), ans.end());
for (i = 0; i < ans.size(); i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1005], nob[1005], off, dp[1005];
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]), nob[a[i]] = 1;
dp[0] = 1;
for (int i = (1); i <= (n); i++)
if (!nob[i]) {
int cnt = 0, x = i, f = 0;
while (x) {
if (f) ++off;
if (x == m) f = 1;
++cnt;
x = a[x];
}
if (!f) {
for (int i = n; i >= cnt; i--) dp[i] |= dp[i - cnt];
}
}
for (int i = (0); i <= (n); i++)
if (dp[i]) printf("%d\n", i + off + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int visit[1001];
int par[1001], sz[1001];
vector<int> ss;
int dfs(int &u) {
int ever = visit[u] ^ 1;
visit[u] = 1;
if (par[u] == 0) return ever;
u = par[u];
return ever + dfs(u);
}
int dp[1005], temp[1005];
int main() {
int n, x, a, b, i, j;
cin >> n >> x;
for (i = 1; i <= n; ++i) par[i] = i;
for (i = 1; i <= n; ++i) cin >> par[i];
int k = x, u, ret;
int pos = dfs(k);
sz[k] += pos;
for (i = 1; i <= n; ++i) {
if (!visit[i]) {
u = i;
ret = dfs(u);
sz[u] += ret;
}
}
for (i = 1; i <= n; ++i)
if (par[i] == 0 && i != k) ss.push_back(sz[i]);
dp[0] = 1;
for (i = 0; i < ss.size(); ++i) {
memcpy(temp, dp, sizeof(dp));
for (j = 0; j < n; ++j)
if (dp[j]) temp[j + ss[i]] = 1;
memcpy(dp, temp, sizeof(temp));
}
for (i = 0; i < n; ++i)
if (dp[i] == 1) cout << i + pos << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int PRIME = 999983;
const int MOD = 1000000007;
const int MULTI = 1000000007;
const double EPS = 1e-8;
inline bool isodd(int x) { return x & 1; }
inline bool isodd(long long x) { return x & 1; }
bool vis[100010];
class DisjointSet {
public:
int parent[100010], sum[100010];
void init(int n) {
for (int i = 0; i <= n; i++) parent[i] = i, sum[i] = 1;
}
int find(int x) { return x == parent[x] ? x : (parent[x] = find(parent[x])); }
void merger(int x, int y) {
int rtx = find(x);
int rty = find(y);
parent[rtx] = rty;
sum[rty] += sum[rtx];
vis[rty] = vis[rtx] || vis[rty];
}
} ds;
set<int> ans;
vector<int> d;
int dp[1100];
int main() {
int n, x, a;
scanf("%d%d", &n, &x);
ds.init(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
if (a && a != x) {
ds.merger(a, i);
}
if (a == x) vis[ds.find(i)] = true;
}
int tmp;
tmp = ds.sum[ds.find(x)];
for (int i = 1; i <= n; i++) {
if (ds.parent[i] != i || i == ds.find(x) || vis[i]) continue;
d.push_back(ds.sum[i]);
}
memset(dp, -1, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < d.size(); i++) {
for (int j = n; j >= d[i]; j--) {
if (dp[j - d[i]] != -1) dp[j] = 1;
}
}
for (int i = 0; i <= n; i++)
if (dp[i] != -1) printf("%d\n", i + tmp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1010], g[1010], d[1010];
bool f[1010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
for (g[i] = i; a[g[i]]; g[i] = a[g[i]])
;
}
for (int i = 1; i <= n; i++) d[g[i]]++;
d[g[k]] = 0;
int add = 0;
for (int i = k; i; i = a[i]) add++;
f[0] = true;
for (int i = 1; i <= n; i++) {
if (!d[i]) continue;
for (int j = n; j >= d[i]; j--) {
f[j] |= f[j - d[i]];
}
}
for (int i = 0; i <= n; i++)
if (f[i]) printf("%d\n", i + add);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int a[maxn];
int cnt[maxn];
vector<int> p;
int n, x;
bool bb;
int dfs(int v) {
if (v == x) bb = true;
if (v == 0) return 0;
return 1 + dfs(a[v]);
}
char dp[maxn + 1][maxn + 1];
int main(int argc, char **argv) {
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]] = 1;
}
int dd = dfs(x);
for (int i = 1; i <= n; i++)
if (i != x && cnt[i] == 0) {
bb = false;
int d = dfs(i);
if (!bb) p.push_back(d);
}
dp[0][0] = 1;
for (int i = 1; i <= p.size(); i++) {
for (int w = 0; w <= maxn; w++) {
dp[w][i] = dp[w][i - 1];
if (w - p[i - 1] >= 0) {
dp[w][i] |= dp[w - p[i - 1]][i - 1];
}
}
}
set<int> s;
s.insert(0);
for (int i = 1; i <= maxn; i++)
if (dp[i][p.size()]) s.insert(i);
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
cout << *it + dd << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[1002], a[1002], p[1002], p1[1002], used[1002], us[1002];
vector<int> vec;
int main() {
int n, x, k, l = 0, m, i, j, top, f;
scanf("%d%d", &n, &x);
m = x;
for (i = 1; i <= n; i++) {
scanf("%d", &p1[i]);
if (p1[i] != 0) p[p1[i]] = i;
}
k = 1;
while (p1[x] != 0) k++, x = p1[x];
top = k;
for (i = 1; i <= n; i++)
if (p1[i] == 0) {
j = i;
k = 1;
f = 0;
while (p[j] != 0) {
if (j == m) f = 1;
used[j] = 1;
k++;
j = p[j];
}
used[j] = 1;
if (j == m) f = 1;
if (!f) l++, a[l] = k;
}
d[0] = 1;
for (i = 1; i <= l; i++)
for (j = n; j >= a[i]; j--)
if (d[j - a[i]]) {
if (!us[j]) vec.push_back(j + top);
us[j] = 1;
d[j] = 1;
}
vec.push_back(top);
sort(vec.begin(), vec.end());
for (i = 0; i < vec.size(); i++) printf("%d\n", vec[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
long long n, m;
int a[maxn];
int rankm;
stack<int> s[maxn];
int to[maxn];
int tot = 1;
bool vis[maxn];
int cnt = 0;
int dp[10005];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 0) {
s[tot].push(i);
to[i] = tot++;
cnt++;
if (m == i) {
rankm = s[to[i]].size();
}
}
}
while (cnt < n) {
for (int i = 1; i <= n; i++) {
if (to[a[i]] && !to[i]) {
s[to[a[i]]].push(i);
to[i] = to[a[i]];
cnt++;
if (m == i) {
rankm = s[to[i]].size();
}
}
}
}
int sum = 0;
for (int i = 1; i < tot; i++) {
if (i == to[m]) continue;
sum += s[i].size();
}
dp[0] = 1;
for (int i = 1; i < tot; i++) {
if (i == to[m]) continue;
int len = s[i].size();
for (int j = sum; j >= len; j--) {
if (dp[j - len]) {
dp[j] = 1;
}
}
}
for (int i = 0; i <= sum; i++) {
if (dp[i]) {
printf("%d\n", i + rankm);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
int son[maxn];
bool flag;
bool v[maxn];
bool f[maxn];
int before;
int tot, n, m, x;
void dfs(int now) {
if (now == m) {
before = tot + 1;
flag = true;
}
++tot;
if (son[now]) dfs(son[now]);
}
vector<int> num;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= (n); ++i) {
scanf("%d", &x);
if (x) {
son[x] = i;
v[i] = true;
}
}
for (int i = 1; i <= (n); ++i)
if (!v[i]) {
tot = 0;
flag = false;
dfs(i);
if (!flag) num.push_back(tot);
}
f[0] = true;
for (int i = 0; i < num.size(); ++i)
for (int j = n; j >= num[i]; --j)
if (f[j - num[i]]) f[j] = true;
for (int i = 0; i <= n; ++i)
if (f[i]) cout << before + i << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 1111;
vector<int> G[maxn];
int in[maxn], dp[maxn];
bool dp2[maxn];
int main() {
memset(in, 0, sizeof(in));
memset(dp, 0, sizeof(dp));
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x) {
G[x].push_back(i);
in[i]++;
}
}
queue<int> Q;
for (int i = 1; i <= n; i++) {
if (in[i] == 0) {
Q.push(i);
dp[i] = 1;
}
}
vector<int> arr;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < (G[u].size()); i++) {
int v = G[u][i];
dp[v] = dp[u] + 1;
in[v]--;
if (in[v] == 0) {
Q.push(v);
}
}
if (G[u].size() == 0) {
arr.push_back(dp[u]);
}
}
int tmp = k;
while (G[tmp].size() != 0) {
tmp = G[tmp][0];
}
for (int i = 0; i < (arr.size()); i++)
if (arr[i] == dp[tmp]) {
arr.erase(arr.begin() + i);
break;
}
memset(dp2, 0, sizeof(dp2));
dp2[0] = 1;
for (int i = 0; i < arr.size(); i++) {
for (int j = maxn - 1; j >= arr[i]; j--) {
dp2[j] = dp2[j] | dp2[j - arr[i]];
}
}
vector<int> ans;
for (int i = 0; i < maxn; i++) {
if (dp2[i]) ans.push_back(i + dp[k]);
}
for (int i = 0; i < (ans.size()); i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, j;
int temp, ct;
int base;
long long int val;
bool smart;
cin >> n >> x;
vector<int> next(n + 1, 0);
vector<int> inDeg(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> temp;
if (temp != 0) {
next[i] = temp;
inDeg[temp]++;
}
}
vector<int> sums;
for (int i = 1; i <= n; i++)
if (inDeg[i] == 0) {
j = i;
ct = 1;
smart = false;
if (j == x) smart = true;
while (next[j] != 0) {
j = next[j];
if (j == x) {
smart = true;
break;
}
ct++;
}
if (!smart) sums.push_back(ct);
}
j = x;
base = 1;
while (next[j] != 0) {
j = next[j];
base++;
}
set<long long int> pos;
pos.insert(0);
stack<long long int> toAdd;
for (int i = 0; i < sums.size(); i++) {
val = (long long int)sums[i];
for (auto it = pos.begin(); it != pos.end(); it++) toAdd.push(*it + val);
pos.insert(val);
while (!toAdd.empty()) {
pos.insert(toAdd.top());
toAdd.pop();
}
}
for (auto it = pos.begin(); it != pos.end(); it++) cout << *it + base << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (0u - 1) / 2;
typedef struct Node {
Node *prior;
int data;
Node *next;
} LNode;
int positions[1005];
int path[1005];
LNode *man[1005];
void reset(int n) {
for (int i = 0; i <= n; i++) {
man[i] = new LNode;
man[i]->data = i;
man[i]->prior = man[i]->next = NULL;
}
for (int i = 0; i < 1005; i++) {
path[i] = positions[i] = 0;
}
}
void Delete(int n) {
for (int i = 0; i <= n; i++) {
delete man[i];
}
}
void insert(int e1, int e2) {
if (e2 == 0) return;
man[e1]->next = man[e2];
man[e2]->prior = man[e1];
}
void FindPath(int n, int &sum, int m, int &pOfm) {
LNode *p;
int len;
bool flag = 0;
for (int i = 1; i <= n; i++) {
if (man[i]->prior == NULL) {
p = man[i];
len = 0;
while (p != NULL) {
len++;
if (p->data == m) {
flag = 1;
pOfm = len;
}
p->prior = man[0];
p = p->next;
}
if (flag) {
pOfm = len - pOfm;
}
if (!flag) {
sum++;
path[sum] = len;
}
flag = false;
}
}
}
void showPath(int sum) {
for (int i = 1; i <= sum; i++) cout << path[i] << ' ';
cout << endl;
}
void ans(int sum, int lenOfp, int n) {
positions[lenOfp + 1] = true;
for (int i = 1; i <= sum; i++)
for (int j = n; j >= 1; j--) {
if (positions[j]) positions[j + path[i]] = true;
}
for (int i = 1; i <= n; i++)
if (positions[i]) cout << i << endl;
}
int main() {
int n, m;
int e1, sum = 0, pOfm = 0;
while (cin >> n >> m) {
sum = 0;
reset(n);
for (int i = 1; i <= n; i++) {
cin >> e1;
insert(i, e1);
}
FindPath(n, sum, m, pOfm);
ans(sum, pOfm, n);
Delete(n);
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool dp[1005][1005];
vector<int> v;
int b[1005], A[1005];
int Find(int A[], int x) {
int root = x, tmp;
while (A[root] >= 0) root = A[root];
while (x != root) {
tmp = x;
x = A[x];
A[tmp] = root;
}
return root;
}
void Union(int A[], int a, int b) {
int x = Find(A, a), y = Find(A, b), tmp;
if (x != y) {
if (A[x] > A[y]) {
tmp = x;
x = y;
y = tmp;
}
A[x] += A[y];
A[y] = x;
}
}
int main() {
int n, x, i, j, c = 1, r;
memset(A, -1, sizeof A);
cin >> n >> x;
for (i = 1; i <= n; i++) cin >> b[i];
i = x;
while (b[i]) {
c++;
i = b[i];
}
for (i = 1; i <= n; i++)
if (b[i]) Union(A, i, b[i]);
r = Find(A, x);
for (i = 1; i <= n; i++)
if (A[i] < 0 && i != r) v.push_back(-A[i]);
dp[0][0] = true;
for (i = 1; i <= v.size(); i++)
for (j = 0; j <= n; j++)
if (v[i - 1] > j)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = dp[i - 1][j] | dp[i - 1][j - v[i - 1]];
for (i = 0; i <= n; i++)
if (dp[v.size()][i]) cout << i + c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1002];
int n, k;
long long queues[1002];
vector<long long> lens;
set<long long> lensSet;
int lensCount[1002];
vector<long long> nils;
set<long long> results;
int main() {
scanf("%d %d", &n, &k);
int t;
for (long long i = 1; i <= n; ++i) {
scanf("%d", &t);
a[i] = t;
queues[t] = i;
if (t == 0) nils.push_back(i);
}
long long prev = 0;
{
long long cur = k;
while (a[cur]) {
prev += 1;
cur = a[cur];
}
}
for (vector<long long>::iterator it = nils.begin(); it != nils.end(); it++) {
long long len = 1;
long long cur = *it;
bool ok = cur != k;
while (queues[cur]) {
if (cur == k) {
ok = false;
break;
}
len += 1;
cur = queues[cur];
}
if (ok && cur != k) {
lens.push_back(len);
lensSet.insert(len);
lensCount[len] += 1;
}
}
results.insert(0);
for (set<long long>::iterator it = lensSet.begin(); it != lensSet.end();
it++) {
set<long long> newRes;
newRes.insert(*it);
int nn = lensCount[*it];
for (int e = 1; e <= nn; ++e) {
for (set<long long>::iterator jt = results.begin(); jt != results.end();
jt++) {
newRes.insert(*jt + (*it) * e);
}
}
results.insert(newRes.begin(), newRes.end());
}
for (set<long long>::iterator it = results.begin(); it != results.end();
it++) {
cout << *it + prev + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1002;
int n, X;
int t[nmax];
bool use[nmax];
bool sum[nmax];
vector<int> links;
int main() {
cin >> n >> X;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
use[t[i]] = 1;
}
int smartTop = -1;
for (int i = 1; i <= n; ++i) {
if (!use[i]) {
int qSize = 0;
bool smartB = false;
int j = i;
while (j != 0) {
qSize++;
if (j == X) {
smartB = true;
}
use[j] = true;
j = t[j];
}
if (smartB) {
smartTop = i;
} else {
links.push_back(qSize);
}
}
}
int smartSize = 0, smartPos = 0;
while (smartTop != 0) {
smartSize++;
if (smartTop == X) {
smartPos = smartSize;
}
smartTop = t[smartTop];
}
sort(links.begin(), links.end());
sum[0] = true;
for (int i = 0; i < (int)links.size(); ++i) {
for (int j = n - smartSize; j >= links[i]; --j) {
sum[j] |= sum[j - links[i]];
}
}
smartPos = smartSize - smartPos + 1;
for (int j = 0; j <= n - smartSize; ++j) {
if (sum[j]) {
cout << j + smartPos << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double tau = 2 * pi;
const double epsilon = 1e-9;
const int MAX_N = 100100;
int N, SB;
int nxt[MAX_N];
int prv[MAX_N];
vector<int> cc;
bool vis[MAX_N];
int dfs(int u) {
if (vis[u]) return 0;
vis[u] = true;
if (u == SB)
return -(1 << 30) + dfs(nxt[u]) + dfs(prv[u]);
else
return 1 + dfs(nxt[u]) + dfs(prv[u]);
}
bool sum[MAX_N];
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> N >> SB;
for (int i = 1; i <= N; i++) {
int tmp;
cin >> tmp;
nxt[i] = tmp;
prv[tmp] = i;
}
vis[0] = true;
for (int i = 1; i <= N; i++) {
int ccsz = dfs(i);
if (ccsz > 0) cc.push_back(ccsz);
}
int SBpos = 0, cur = SB;
while (cur != 0) {
cur = nxt[cur];
++SBpos;
}
sum[0] = true;
for (int i = 0; i < ((int)cc.size()); i++)
for (int j = MAX_N - 1; j >= 0; j--)
if (sum[j] && (j + cc[i] < MAX_N)) sum[j + cc[i]] = true;
for (int i = 0; i < MAX_N; i++)
if (sum[i] && (i + SBpos <= N)) cout << i + SBpos << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1011], root[1011];
vector<int> g[1011];
int main() {
int n, x;
cin >> n >> x;
int p[n + 1];
for (int i = 0; i < n; i++) {
cin >> p[i + 1];
root[i + 1] = 1;
if (p[i + 1]) {
root[i + 1] = 0;
g[p[i + 1]].emplace_back(i + 1);
}
}
vector<int> v;
int cur, sz, sp;
bool found = 0;
for (int i = 0; i < n; i++) {
cur = i + 1;
sz = 0;
found = 0;
if (vis[i + 1] or !root[i + 1]) continue;
while (1) {
if (cur == 0) break;
vis[cur] = 1;
if (cur == x) {
sp = sz;
found = 1;
}
if (g[cur].size())
cur = g[cur][0];
else
cur = 0;
sz++;
}
if (!found) v.emplace_back(sz);
}
set<int> s1, s2;
for (auto x : v) {
for (auto y : s1) {
if (y + x <= n) s2.insert(y + x);
}
s2.insert(x);
for (auto y : s2) {
s1.insert(y);
}
s2.clear();
}
sp++;
cout << sp << " ";
for (auto x : s1) {
cout << x + sp << " ";
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T& x) {
stringstream ss;
ss << x;
return ss.str();
}
const double EPS = 1e-6;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const double PI = 3.1415926535897932384626433832795;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
unsigned int gcd(unsigned int a, unsigned int b) {
return a ? gcd(b % a, a) : b;
}
int src[1100];
int head[1100];
int dist[1100];
int len[1100];
int n;
bool dp[1100];
void doit(int a) {
if (len[a]) return;
if (src[a] == -1) {
head[a] = a;
len[a] = 1;
dist[a] = 1;
return;
}
doit(src[a]);
head[a] = head[src[a]];
dist[a] = 1 + dist[src[a]];
len[head[a]] = max(len[head[a]], dist[a]);
}
int main() {
int x;
cin >> n >> x;
--x;
for (int i = 0; i < (n); ++i) {
cin >> src[i];
--src[i];
}
for (int i = 0; i < (n); ++i) {
doit(i);
}
int xpos = dist[x];
vector<int> segs;
for (int i = 0; i < (n); ++i) {
if (src[i] == -1 && i != head[x]) {
segs.push_back(len[i]);
}
}
dp[0] = true;
for (int i = 0; i < (((int)(segs).size())); ++i) {
int s = segs[i];
for (int j = n - s; j >= 0; --j) {
dp[j + s] |= dp[j];
}
}
for (int i = 0; i < (n); ++i) {
if (dp[i]) cout << i + xpos << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[1005], in[1005], dp[1005][1005];
vector<int> v;
int main() {
int n, x, k, len, pos, offset;
scanf("%d", &n);
scanf("%d", &k);
for (int i = int(1); i <= int(n); i++) {
scanf("%d", &x);
if (x) {
par[i] = x;
in[x]++;
}
}
for (int i = int(1); i <= int(n); i++) {
assert(in[i] <= 1);
if (!in[i]) {
x = i;
len = 0;
pos = -1;
while (x) {
len++;
if (x == k) pos = len;
x = par[x];
}
if (pos != -1)
offset = len - pos + 1;
else
v.push_back(len);
}
}
n = v.size();
dp[0][0] = 1;
for (int i = int(1); i <= int(n); i++) {
for (int j = int(0); j <= int(1000); j++) {
if (dp[i - 1][j]) dp[i][j] = dp[i][j + v[i - 1]] = 1;
}
}
for (int j = int(0); j <= int(1000); j++) {
if (dp[n][j]) cout << j + offset << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
int color[N], now;
vector<int> G[N], parts[N], path, d;
bool dp[N + 1];
void dfs(int v) {
path.push_back(v);
if (G[v].empty()) {
reverse(path.begin(), path.end());
for (int i = 0; i < path.size(); i++) color[path[i]] = now;
parts[now++] = path;
path.clear();
return;
}
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (color[u] != -1) {
reverse(path.begin(), path.end());
for (int j = 0; j < path.size(); j++) {
color[path[j]] = color[u];
parts[color[u]].push_back(path[j]);
}
path.clear();
return;
}
dfs(u);
}
}
int main() {
int n, x, u, cnt = 0;
cin >> n >> x;
x--;
for (int i = 0; i < n; i++) {
cin >> u;
if (u) G[i].push_back(u - 1);
}
for (int i = 0; i < n; i++) color[i] = -1;
for (int i = 0; i < n; i++)
if (color[i] == -1) dfs(i);
int pos = -1;
for (int i = 0; i < now; i++) {
bool good = 0;
for (int j = 0; j < parts[i].size(); j++)
if (parts[i][j] == x) {
pos = j + 1;
good = 1;
break;
}
if (!good) d.push_back(parts[i].size());
}
dp[0] = 1;
for (int i = 0; i < d.size(); i++)
for (int j = N - d[i]; j >= 0; j--)
if (dp[j]) dp[j + d[i]] = 1;
for (int i = 0; i <= N; i++)
if (dp[i]) cout << i + pos << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
const int INF = 1 << 29;
const int MAXN = 1005;
int n, x;
int nxt[MAXN];
int prv[MAXN];
int bPos = -1;
int T[MAXN];
vector<int> L;
int traverse(int ind, int depth) {
if (ind == x) {
bPos = depth;
}
if (prv[ind] == -1) {
return 1;
}
return traverse(prv[ind], depth + 1) + 1;
}
int main(int argc, char** argv) {
scanf("%d%d", &n, &x);
x--;
for (int i = 0; i < n; i++) {
prv[i] = -1;
}
for (int i = 0; i < n; i++) {
scanf("%d", &nxt[i]);
nxt[i]--;
if (nxt[i] != -1) {
prv[nxt[i]] = i;
}
}
for (int i = 0; i < n; i++) {
if (nxt[i] == -1) {
int init = bPos;
int len = traverse(i, 1);
if (bPos == init) L.push_back(len);
}
}
T[0] = 1;
for (int i = 0; i < (int)L.size(); i++) {
for (int j = n - 1; j >= 0; j--) {
if (T[j] == 1 && j + L[i] < n) {
T[j + L[i]] = 1;
}
}
}
for (int i = 0; i < n; i++) {
if (T[i] == 1) {
printf("%d\n", i + bPos);
}
}
return 0;
}
|
#include <bits/stdc++.h>
struct Patient {
unsigned int previous;
unsigned int next;
unsigned int group;
Patient() {
previous = 0;
next = 0;
group = 0;
}
};
unsigned int patientCount;
unsigned int smartBeaver;
Patient patients[1001];
unsigned int groupSizes[1001] = {0};
unsigned int groupCount = 0;
void readInput() {
std::cin >> patientCount >> smartBeaver;
for (unsigned int i = 1; i <= patientCount; i++) {
unsigned int next;
std::cin >> next;
if (next != 0) {
patients[i].next = next;
patients[next].previous = i;
}
}
}
void goGroup(unsigned int i, unsigned int group) {
if (i == 0) return;
if (patients[i].group != 0) return;
groupSizes[group]++;
patients[i].group = group;
goGroup(patients[i].previous, group);
goGroup(patients[i].next, group);
}
unsigned int getBeaverGroupPos(unsigned int i) {
if (patients[i].next == 0)
return 1;
else
return getBeaverGroupPos(patients[i].next) + 1;
}
std::set<unsigned int> sums;
unsigned int beenHere[1001];
void generateSums(unsigned int i, unsigned int sum) {
if (beenHere[sum] <= i) return;
if (i == groupCount) {
sums.insert(sum);
return;
}
generateSums(i + 1, sum);
beenHere[sum] = i;
generateSums(i + 1, sum + groupSizes[i]);
}
void solve() {
for (unsigned int i = 1; i <= patientCount; i++) {
if (patients[i].group == 0) {
goGroup(i, ++groupCount);
}
}
unsigned int smartBeaverGroupPos = getBeaverGroupPos(smartBeaver);
std::swap(groupSizes[patients[smartBeaver].group], groupSizes[groupCount]);
std::random_shuffle(groupSizes + 1, groupSizes + groupCount);
for (unsigned int i = 0; i <= 1000; i++) {
beenHere[i] = UINT_MAX;
}
generateSums(1, smartBeaverGroupPos);
for (unsigned int sum : sums) {
std::cout << sum << std::endl;
}
}
int main() {
readInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 999999999;
const double PI = 3.1415931;
const double eps = 1e-9;
const int maxN = 10000;
int n, m;
bool mark[maxN];
int adj[maxN];
int deg[maxN];
int dfs(int x) {
if (x == 0) return 0;
if (x == m)
return maxN;
else
return dfs(adj[x]) + 1;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x) {
adj[i] = x;
deg[x]++;
}
}
int ans = dfs(adj[m]);
ans++;
vector<int> q;
for (int i = 1; i <= n; i++) {
if (deg[i] == 0) {
if (dfs(i) < maxN) q.push_back(dfs(i));
}
}
mark[ans] = true;
for (int i = 0; i < q.size(); i++) {
vector<int> v;
for (int j = 0; j < 1001; j++) {
if (mark[j]) v.push_back(j + q[i]);
}
for (int j = 0; j < v.size(); j++) mark[v[j]] = true;
}
for (int i = 1; i <= n; i++)
if (mark[i]) cout << i << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
long long MOD = 1e9 + 7;
const char nl = '\n';
const long long inf = 1e15;
long long power(long long x, long long y) {
long long z = 1;
while (y > 0) {
if (y % 2) z = z * x;
x = x * x;
y /= 2;
}
return z;
}
long long gcd(long long a, long long b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
long long sq(long long a) {
long long ans = (1ll * a * a);
return ans;
}
int n, x;
vector<vector<int>> g(1001);
int par[1001];
int pos[1001];
int vis[1001];
set<int> ans(vector<int> nums, int ptr) {
if (ptr == nums.size()) {
set<int> t;
t.insert(0);
return t;
}
set<int> bakra = ans(nums, ptr + 1);
set<int> ret = bakra;
for (int ele : bakra) {
ret.insert(ele + nums[ptr]);
}
return ret;
}
void dfs(int node, int position, int color) {
pos[node] = position;
vis[node] = color;
for (int child : g[node]) {
if (vis[child] == -1) {
dfs(child, position + 1, color);
}
}
}
void solve() {
memset(pos, -1, sizeof(pos));
memset(par, -1, sizeof(par));
memset(vis, -1, sizeof(vis));
cin >> n >> x;
for (int i = 1; i <= n; i++) {
int temp;
cin >> temp;
if (temp != 0) {
par[i] = temp;
g[temp].push_back(i);
}
}
int color = 0;
for (int i = 1; i <= n; i++) {
if (par[i] == -1) {
color++;
dfs(i, 0, color);
}
}
int fre[color + 1];
memset(fre, 0, sizeof(fre));
for (int i = 1; i <= n; i++) {
fre[vis[i]]++;
}
vector<int> nums;
for (int i = 1; i <= color; i++) {
if (vis[x] != i) {
nums.push_back(fre[i]);
}
}
set<int> retard = ans(nums, 0);
for (auto it : retard) {
cout << it + pos[x] + 1 << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long TC = 1;
while (TC--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1024], n, x, fr[1024], dp[1024], i, j, pl;
int main() {
cin >> n >> x;
dp[0] = 1;
for (i = 1; i <= n; i++) {
cin >> a[i];
fr[a[i]]++;
}
for (i = 1; i <= n; i++)
if (!fr[i]) {
int c = 0, flag = -1;
for (j = i; j; j = a[j]) {
if (j == x) flag = c;
c++;
}
if (flag >= 0) {
pl = c - flag;
continue;
}
for (j = n; j >= c; j--) dp[j] |= dp[j - c];
}
for (i = 0; i <= n; i++)
if (dp[i]) cout << i + pl << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[100005], vis[100005], valid[100005];
vector<int> v[100005];
int res[100005], dis[100005], nex[1000005];
int dfs(int cur, int d) {
dis[cur] = d;
vis[cur] = 1;
if (v[cur].size()) return dfs(v[cur][0], d + 1);
return d;
}
int main() {
int n, x, k;
scanf("%d%d", &n, &k);
vector<int> di;
int i;
for (i = 1; i <= n; i++) scanf("%d", &fa[i]);
for (i = 1; i <= n; i++) {
if (fa[i])
v[fa[i]].push_back(i);
else
valid[i] = 1;
}
int pr = 0;
for (i = 1; i <= n; i++) {
if (valid[i]) {
int l = dfs(i, 1);
if (pr == 0 && vis[k] == 1)
res[dis[k]] = 1;
else
di.push_back(l);
pr += vis[k];
}
}
int j;
for (i = 0; i < di.size(); i++) {
for (j = 1; j <= n; j++)
if (res[j] == 1) nex[j + di[i]] = 1;
for (j = 1; j <= n; j++)
if (nex[j] == 1) res[j] = 1;
}
for (i = 1; i <= n; i++)
if (res[i]) printf("%d\n", i);
}
|
#include <bits/stdc++.h>
using namespace std;
int xpos;
int n, x;
vector<int> lens;
int head[1050], back[1050], dp[1050];
int main() {
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> head[i];
back[head[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (head[i]) continue;
int len = 1;
int j = i;
while (back[j] && len) {
if (j == x) {
xpos = len;
len = 0;
break;
}
len++;
j = back[j];
}
if (j == x && len) {
xpos = len;
len = 0;
}
if (len) lens.push_back(len);
}
dp[0] = 1;
for (int i = 0; i < lens.size(); i++) {
for (int j = n + 1; j - lens[i] >= 0; j--) {
dp[j] |= dp[j - lens[i]];
}
}
for (int i = 0; i <= n + 1; i++) {
if (dp[i] && i + xpos) cout << i + xpos << endl;
}
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 (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>
int n, x, a[1024], b[1024], v[1024] = {1};
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), ++b[a[i]];
int t = 0;
for (int i = 1; i <= n; ++i)
if (!b[i]) {
int z = 0, f = 0;
for (int j = i; j > 0; j = a[j], ++z)
if (f |= j == x) ++t;
if (!f)
for (int j = n; j >= z; --j) v[j] |= v[j - z];
}
for (int i = 0; i < n; ++i)
if (v[i]) printf("%d\n", i + t);
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], f[N];
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++)
for (int j = n; j >= a[i]; j--) f[j] |= f[j - a[i]];
for (int i = 0; i + pos <= n; i++)
if (f[i]) write(i + pos), puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
const long long mod = 1e9;
int n, x, par[1100], p[1100], vis[1100], d[1100];
vector<int> q[1100];
inline int dfs(int v) {
cerr << "in dfs " << v << endl;
if (par[v] == v) return par[v];
return par[v] = dfs(par[v]);
}
inline int DFS(int v) {
if (p[v] == 0) {
return d[v] = 1;
}
return d[v] = DFS(p[v]) + 1;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> par[i];
p[i] = par[i];
if (!par[i]) {
par[i] = i;
d[i] = 1;
}
}
d[0] = 0;
vis[0] = 1;
for (int i = 1; i <= n; i++) {
dfs(i);
DFS(i);
}
int hlp = par[x], ind = d[x];
for (int i = 1; i <= n; i++) {
q[par[i]].push_back(i);
}
for (int i = 1; i <= n; i++)
if (par[x] != i)
for (int j = n; j >= 0; j--)
if (vis[j] && j + q[i].size() <= 1100) vis[j + q[i].size()] = 1;
for (int i = 0; i <= n; i++)
if (vis[i]) cout << i + ind << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[1010], Next[1010];
vector<int> length;
int dp[1010];
int main() {
int i, j, n, x, l;
while (cin >> n >> x) {
int pos = -1;
for (i = 1; i <= n; i++) {
cin >> pre[i];
Next[pre[i]] = i;
}
for (i = 1; i <= n; i++) {
if (pre[i] == 0) {
int cot = 0;
j = i;
while (j != 0) {
cot++;
if (j == x) {
pos = cot;
break;
}
j = Next[j];
}
if (j == 0) length.push_back(cot);
}
}
l = length.size();
dp[0] = 1;
for (i = 0; i < l; i++) {
for (j = n; j >= length[i]; j--) {
if (dp[j - length[i]]) dp[j] = 1;
}
}
for (i = 0; i <= n; i++) {
if (dp[i]) cout << i + pos << endl;
}
memset(dp, 0, sizeof(dp));
memset(Next, 0, sizeof(Next));
length.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w;
int a[1005];
bool vis[1005];
int b[1005];
int p;
int l;
void dfs(int x) {
vis[x] = true;
l++;
if (x == 0) return;
dfs(a[x]);
}
int ff;
int m = 0;
int t = 0;
int c[1005];
bool rt[1005];
bool rr[1005];
int main() {
scanf("%d%d", &n, &w);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x] = i;
if (x == 0) rr[i] = true;
}
for (int i = 1; i <= n; i++) {
if (rr[i]) {
ff = 0;
if (vis[w] == false) ff = 1;
l = 0;
dfs(i);
if (ff == 1 && vis[w] == true) {
t = l;
continue;
}
p++;
b[p] = l - 1;
}
}
l = 0;
dfs(w);
l = t - l;
l++;
m = 1;
c[m] = 0;
for (int i = 1; i <= p; i++) {
int tmp = m;
for (int j = 1; j <= tmp; j++) {
if (rt[c[j] + b[i]]) continue;
m++;
c[m] = c[j] + b[i];
rt[c[j] + b[i]] = true;
}
}
for (int i = 1; i <= m; i++) rt[c[i]] = true;
for (int i = 0; i <= n; i++) {
if (rt[i]) {
printf("%d\n", i + l);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 5e-12;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void fft(vector<complex<long double> > &a, bool invert) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1) j -= bit;
j += bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
long double ang = 2 * PI / len * (invert ? -1 : 1);
complex<long double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<long double> w(1);
for (int j = 0; j < len / 2; ++j) {
complex<long double> u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; ++i) a[i] /= n;
}
inline void input(int &a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(long long a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[20];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
struct lnum {
vector<int> a;
int base;
lnum(int num = 0, int base = 1000000000) : base(base) {
if (!num) a.resize(1);
while (num) {
a.push_back(num % base);
num /= base;
}
}
inline int len() const { return a.size(); }
lnum &operator=(const lnum &l) {
if (this != &l) {
a = l.a;
base = l.base;
}
return *this;
}
inline friend lnum operator+(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int ln = l.len(), rn = r.len();
int n = max(ln, rn);
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = o;
if (i < ln) s += l.a[i];
if (i < rn) s += r.a[i];
o = s >= base;
if (o) s -= base;
ret.a[i] = s;
}
if (o) ret.a.push_back(1);
return ret;
}
inline friend lnum operator-(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int n = l.len();
int rn = r.len();
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = l.a[i] - o;
if (i < rn) s -= r.a[i];
o = s < 0;
if (o) s += base;
ret.a[i] = s;
}
if (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator*(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
if (l.len() * r.len() > 1000000) {
vector<complex<long double> > fa(l.a.begin(), l.a.end()),
fb(r.a.begin(), r.a.end());
int n = 1;
while (n < max(l.len(), r.len())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
fft(fa, false), fft(fb, false);
for (int i = 0; i < n; ++i) fa[i] *= fb[i];
fft(fa, true);
ret.a.resize(n);
for (int i = 0; i < n; ++i) ret.a[i] = int(fa[i].real() + 0.5);
int carry = 0;
for (int i = 0; i < n; ++i) {
ret.a[i] += carry;
carry = ret.a[i] / base;
ret.a[i] %= base;
}
} else {
ret.a.resize(l.len() + r.len());
for (int i = 0; i < l.len(); ++i)
for (int j = 0, carry = 0; j < r.len() || carry; ++j) {
long long cur = ret.a[i + j] +
(long long)l.a[i] * (j < r.len() ? r.a[j] : 0) +
carry;
ret.a[i + j] = cur % base;
carry = cur / base;
}
}
while (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator/(const lnum &l, const int &r) {
lnum ret(0, l.base);
ret.a.resize(l.len());
int carry = 0;
for (int i = l.len() - 1; i >= 0; --i) {
long long cur = l.a[i] + (long long)carry * l.base;
ret.a[i] = cur / r;
carry = cur % r;
}
while (ret.len() > 1 && ret.a.back() == 0) ret.a.pop_back();
return ret;
}
inline friend bool operator<(const lnum &l, const lnum &r) {
if (l.len() < r.len()) return true;
if (l.len() > r.len()) return false;
int n = l.len();
for (int i = n - 1; i >= 0; --i) {
if (l.a[i] < r.a[i]) return true;
if (l.a[i] > r.a[i]) return false;
}
return false;
}
inline friend bool operator>(const lnum &l, const lnum &r) { return r < l; }
inline friend bool operator==(const lnum &l, const lnum &r) {
if (l.len() != r.len()) return false;
int n = l.len();
for (int i = n - 1; i; --i) {
if (l.a[i] != r.a[i]) return false;
}
return true;
}
inline friend bool operator!=(const lnum &l, const lnum &r) {
return !(l == r);
}
inline void print() {
if (base == 1000000000) {
printf("%d", a.back());
for (int i = a.size() - 2; i >= 0; --i) printf("%09d", a[i]);
} else {
for (int i = a.size() - 1; i >= 0; --i) printf("%d", a[i]);
}
}
};
int main() {
int(n);
input((n));
;
int(first);
input((first));
;
--first;
int to[n];
memset(to, 255, sizeof(to));
vector<int> beg;
for (int i = 0; i < (int)(n); i++) {
int a = nxt() - 1;
if (a != -1)
to[a] = i;
else
beg.push_back(i);
}
vector<int> s;
int pos = 0;
char used[n];
memset((used), 0, sizeof(used));
for (int i = 0; i < (int)(beg.size()); i++) {
int cur = beg[i];
int l = 1;
int fl = true;
while (1) {
if (cur == first) {
pos = l;
fl = false;
}
used[cur] = 1;
if (to[cur] != -1) {
++l;
cur = to[cur];
} else
break;
}
if (fl) s.push_back(l);
}
char can[n + 1];
memset((can), 0, sizeof(can));
can[0] = 1;
for (int i = 0; i < (int)(s.size()); i++) {
char tmp[n + 1];
memcpy(tmp, can, sizeof(can));
for (int j = (s[i]); j <= (int)(n); j++)
if (tmp[j - s[i]]) can[j] = 1;
}
for (int i = 0; i < (int)(n + 1); i++)
if (can[i]) cout << i + pos << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool table[1010];
int mae[1010], ato[1010];
int n, x;
void init() {}
void input() {
for (int i = (0); i < (1010); i++) table[i] = false;
table[0] = true;
cin >> n >> x;
for (int i = (0); i < (1010); i++) mae[i] = ato[i] = 0;
for (int i = (0); i < (n); i++) cin >> mae[i + 1];
for (int i = (1); i < (n + 1); i++) ato[mae[i]] = i;
}
void solve() {
vector<int> re;
int mae_me;
for (int i = (1); i < (n + 1); i++)
if (mae[i] == 0) {
bool me = false;
int cnt = 0;
int ptr = i;
while (1) {
if (ptr == x) {
me = true;
mae_me = cnt;
break;
}
cnt++;
if (ato[ptr] == 0) break;
ptr = ato[ptr];
}
if (!me) re.push_back(cnt);
}
for (int i = (0); i < (((int)re.size())); i++) {
int tmp[1010];
for (int j = (0); j < (1010); j++) tmp[j] = table[j];
for (int j = (0); j < (1010); j++)
if (table[j]) tmp[j + re[i]] = true;
for (int j = (0); j < (1010); j++) table[j] = tmp[j];
}
for (int i = (0); i < (1010); i++)
if (table[i]) cout << i + mae_me + 1 << endl;
}
int main() {
init();
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
const int inf = 1e9 + 7;
const long long mod = 1e9 + 7;
int a[maxn];
int g[maxn];
int vis[maxn];
int dp[maxn][maxn];
int n, x;
int xpos = -1;
bool contains_x;
int dfs(int u) {
if (vis[u]) {
return 0;
}
vis[u] = 1;
int res = 1;
if (a[u] == -1) {
res = 1;
} else {
res = dfs(a[u]) + 1;
}
if (u == x) {
contains_x = true;
xpos = res;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> x;
x--;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
if (a[i] != -1) {
g[a[i]] = true;
}
}
vector<int> v;
for (int i = 0; i < n; i++) {
if (!vis[i] && !g[i]) {
contains_x = false;
int len = dfs(i);
if (!contains_x) {
v.push_back(len);
}
}
}
dp[0][xpos] = 1;
for (int i = 0; i < v.size(); i++) {
for (int j = 1; j <= n; j++) {
dp[i + 1][j] |= dp[i][j];
if (j + v[i] <= n) {
dp[i + 1][j + v[i]] |= dp[i][j];
}
}
}
for (int j = 1; j <= n; j++) {
if (dp[v.size()][j] == 1) {
cout << j << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000001;
const double PI = acos(-1);
const long long INFLL = 0x7FFFFFFFFFFFFFFF;
const int INF = 0x7FFFFFFF;
template <typename T>
inline void next(T &num) {
char c;
num = 0;
do {
c = getchar_unlocked();
} while (c != EOF && c == ' ' && c == '\n' && c == '\t');
int sign = (c == '-' ? -1 : 1);
if (c != '-') num += (c - '0');
while ((c = getchar_unlocked()) != EOF && c != '\n' && c != '\t' &&
c != ' ') {
num *= 10;
num += (c - '0');
}
num *= sign;
}
int nx[1005], n, x;
bitset<1005> sabi;
vector<int> pin;
pair<int, int> cari(int init, int num) {
int pos = 0, pjg = 0;
for (; init; init = nx[init], ++pjg)
if (init == num) pos = pjg + 1;
return make_pair(pos, pjg);
}
int main() {
scanf("%d%d", &n, &x);
for (int i = int(1), _b = int(n); i <= _b; ++i) {
int t;
scanf("%d", &t);
if (t)
nx[t] = i;
else
pin.push_back(i);
}
sabi[0] = 1;
int pos;
for (__typeof(pin.begin()) i = pin.begin(); i != pin.end(); i++) {
int cur = *i;
pair<int, int> tmp = cari(cur, x);
if (tmp.first) {
pos = tmp.first;
continue;
}
for (int i = int(1000 - tmp.second), _b = int(0); i >= _b; --i)
if (sabi[i]) sabi[i + tmp.second] = 1;
}
for (int i = int(0), _b = int(n - pos); i <= _b; ++i)
if (sabi[i]) printf("%d\n", pos + i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[1010], a[1010], n, x, m, all;
vector<int> ans, cnt;
bool f[1010];
int main() {
scanf("%d%d", &n, &x);
cnt.clear();
ans.clear();
memset(p, 0, sizeof(p));
memset(a, 0, sizeof(a));
int c, i, y, cc;
for (i = 1; i <= n; i++) {
scanf("%d", &c);
p[i] = c;
a[c] = i;
}
c = 1;
for (i = x; p[i]; i = p[i]) c++;
p[i] = -1;
for (i = 1; i <= n; i++)
if (p[i] == 0) {
cc = 1;
for (int j = i; a[j]; j = a[j]) cc++;
cnt.push_back(cc);
}
memset(f, false, sizeof(f));
f[0] = true;
for (int i = 0; i < cnt.size(); i++) {
for (int j = n; j >= cnt[i]; j--) f[j] = f[j] || f[j - cnt[i]];
}
ans.push_back(c);
for (int i = 1; i <= n - c; i++)
if (f[i]) ans.push_back(i + c);
sort(ans.begin(), ans.end());
m = unique(ans.begin(), ans.end()) - ans.begin();
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int c = 1002;
int n, x, t[c], kov[c], ert;
bool v[c];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> t[i];
if (t[i]) {
kov[t[i]] = i;
}
}
v[0] = true;
for (int i = 1; i <= n; i++) {
if (!t[i]) {
int db = 0, sp = 0, pos = i;
while (pos) {
db++;
if (pos == x) {
ert = db, sp = 1;
}
pos = kov[pos];
}
if (!sp) {
for (int i = n; i >= 0; i--) {
if (v[i]) {
v[i + db] = true;
}
}
}
}
}
for (int i = 0; i <= n; i++) {
if (v[i]) {
cout << i + ert << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, s[1002], t[1002], pp = 0;
bool v[1002];
scanf("%d %d", &n, &m);
memset(t, 0, sizeof(t));
memset(v, 0, sizeof(v));
for (int i = 1; i <= n; i++) scanf("%d", &s[i]), t[s[i]] = i;
int tmp = m;
while (tmp != 0) {
v[tmp] = true;
tmp = s[tmp];
pp++;
}
int dp[1002][2];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++)
dp[j][i % 2] = max(dp[j][i % 2], dp[j][(i - 1) % 2]);
if (!v[i] && s[i] == 0) {
int tmp = i, k = 1;
while (t[tmp] != 0) {
v[tmp] = true;
tmp = t[tmp];
++k;
}
for (int j = 0; j <= n - k; j++) {
if (dp[j][(i - 1) % 2] == 1) dp[j + k][i % 2] = dp[j][i % 2] = 1;
}
}
}
for (int i = 0; i <= n; i++) {
if (dp[i][n % 2] == 1) printf("%d\n", i + pp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Sol {
const int N = 1010;
int n, x;
int pre[N];
bool vst[N];
bool in[N];
int belong;
int posx;
bool f[N];
struct Bg {
int x;
} bg[N];
int tot = 0;
int pos = 0;
void dfs(int u) {
if (u == 0) return;
dfs(pre[u]);
pos++;
if (u == x) {
belong = tot;
posx = pos;
}
bg[tot].x++;
}
void sol() {
memset(in, 0, sizeof(in));
memset(f, 0, sizeof(f));
scanf("%d", &n);
scanf("%d", &x);
for (int i = 1; i < n + 1; ++i) {
scanf("%d", &pre[i]);
in[pre[i]] = 1;
}
for (int i = 1; i < n + 1; ++i) {
if (!in[i]) {
pos = 0;
dfs(i);
tot++;
}
}
f[0] = 1;
for (int i = 0; i < tot; ++i) {
if (i == belong) continue;
for (int v = n; v >= bg[i].x; --v) {
if (f[v - bg[i].x]) f[v] = 1;
}
}
for (int i = 0; i < n; ++i) {
if (f[i]) {
printf("%d\n", posx + i);
}
}
}
} // namespace Sol
int main() {
Sol::sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1100], ne[1100];
vector<int> ve[1100];
bool look[1100];
int main() {
int n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ne[a[i]] = i;
}
int counter = 0;
int ans = 0, anspos = 0;
for (int i = 1; i <= n; i++) {
if (!a[i]) {
int temp = i;
while (temp) {
ve[counter].push_back(temp);
if (temp == x) {
ans = counter;
anspos = ve[counter].size();
}
temp = ne[temp];
}
counter++;
}
}
look[0] = 1;
for (int i = 0; i < counter; i++) {
if (i != ans)
for (int j = 1100 - 1; j >= 0; j--) {
if (look[j]) {
look[j + ve[i].size()] = 1;
}
}
}
for (int i = 0; i < 1100; i++) {
if (look[i]) cout << i + anspos << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e3 + 5;
vector<int> Ans, G[MaxN];
int id[MaxN], n, pos, cnt, x, last, num[MaxN], depth[MaxN];
bool dp[MaxN];
void Dfs(int u, int now, int dep) {
id[u] = now;
++num[now];
depth[u] = dep;
int Size = G[u].size();
for (int i = 0; i < Size; ++i) {
Dfs(G[u][i], now, dep + 1);
}
}
int main() {
scanf("%d %d", &n, &x);
for (int i = 1; i <= n; ++i) {
scanf("%d", &last);
G[last].push_back(i);
}
int Size = G[0].size();
for (int i = 0; i < Size; ++i) {
Dfs(G[0][i], i + 1, 1);
}
pos = id[x];
dp[0] = true;
for (int i = 0; i < Size; ++i) {
if (id[G[0][i]] == pos) continue;
int p = num[id[G[0][i]]];
for (int j = n; j >= p; j--) {
dp[j] |= dp[j - p];
}
}
int p = num[id[x]];
for (int j = n; j >= p; --j) {
if (dp[j - p]) Ans.push_back(j - p + depth[x]);
}
sort(Ans.begin(), Ans.end());
Size = Ans.size();
for (int i = 0; i < Size; ++i) {
printf("%d\n", Ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
int a[1010], b[1010], rank[1010];
bool c[1010], d[1010];
int find(int k) {
if (b[k] != k) b[k] = find(b[k]);
return b[k];
}
int front(int k) {
int ans = 1;
while (a[k] != 0) {
k = a[k];
ans++;
}
return ans;
}
int main() {
int i, j, n, x, s, t, ans;
scanf("%d%d", &n, &x);
memset(c, false, sizeof(c));
memset(d, false, sizeof(d));
for (i = 1; i <= n; i++) {
rank[i] = 1;
b[i] = i;
}
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) {
s = find(a[i]);
t = find(i);
if (s != t) {
b[s] = t;
rank[t] += rank[s];
}
}
}
t = find(x);
c[0] = true;
for (i = 1; i <= n; i++) {
s = find(i);
if ((s != t) && (d[s] == false)) {
for (j = n - rank[s]; j >= 0; j--)
if (c[j] == true) c[j + rank[s]] = true;
d[s] = true;
}
}
ans = front(x);
for (i = 0; i <= n; i++)
if ((c[i] == true) && (i + ans <= n)) printf("%d\n", i + ans);
return 0;
}
|
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
int a[1005], g[1005], c[1005], dp[1005];
int main(void) {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
for (g[i] = i; a[g[i]]; g[i] = a[g[i]])
;
for (int i = 1; i <= n; i++) c[g[i]]++;
c[g[x]] = 0;
int ans = 0;
for (int i = x; i; i = a[i]) ++ans;
dp[0] = 1;
for (int i = 1; i <= n; i++)
if (c[i])
for (int j = n - c[i]; j >= 0; j--) dp[j + c[i]] |= dp[j];
for (int i = 0; i <= n; i++)
if (dp[i]) printf("%d\n", i + ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, x;
cin >> n >> x;
vector<vector<int> > adj;
adj.resize(n + 1);
map<int, int> A;
int a[n + 1];
int s;
for (int i = 0; i < n; ++i) {
a[i + 1] = 0;
}
for (int i = 1; i <= n; ++i) {
cin >> s;
if (s != 0) {
adj[i].push_back(s);
a[s] = 1;
}
}
vector<int> elements;
if (adj[x].size() == 0) {
A[1]++;
}
for (int i = 1; i <= n; ++i) {
int cnt = 1;
int d = 0;
if (a[i] == 0) {
s = i;
while (adj[s].size() != 0) {
if (s == x) {
d = 1;
cnt = 2;
s = adj[x][0];
} else {
cnt++;
s = adj[s][0];
}
}
if (d == 0 && s != x) {
elements.push_back(cnt);
} else if (d == 1) {
A[cnt]++;
}
}
}
for (int i = 0; i < elements.size(); ++i) {
vector<int> add;
for (map<int, int>::iterator it = A.begin(); it != A.end(); ++it) {
add.push_back(it->first + elements[i]);
}
for (int j = 0; j < add.size(); ++j) {
A[add[j]]++;
}
}
for (map<int, int>::iterator it = A.begin(); it != A.end(); ++it) {
cout << it->first << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int a[maxn], n, x;
bool mark[maxn];
vector<int> v;
int can[maxn][maxn], x_bood, pos_x;
vector<int> adj[maxn];
int dfs_visit(int v, int cnt) {
if (!v) return 0;
if (v == x) x_bood = cnt + 1;
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++)
if (!mark[adj[v][i]]) return 1 + dfs_visit(adj[v][i], cnt + 1);
return 1;
}
void dfs() {
for (int i = 1; i <= n; i++)
if (!mark[i] && !a[i - 1]) {
int tmp = dfs_visit(i, 0);
if (!x_bood)
v.push_back(tmp);
else {
pos_x = x_bood;
x_bood = 0;
}
}
}
void input() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i]) {
adj[i + 1].push_back(a[i]);
adj[a[i]].push_back(i + 1);
}
}
dfs();
}
void knap() {
for (int i = 0; i <= n; i++) can[0][i] = 1;
for (int j = 1; j <= v.size(); j++) {
for (int i = 1; i <= n; i++) {
if (can[i][j - 1]) {
can[i][j] = 1;
} else if (i >= v[j - 1] && can[i - v[j - 1]][j - 1]) {
can[i][j] = 1;
}
}
}
}
void solve() {
for (int i = 0; i <= n; i++)
if (can[i][v.size()]) cout << i + pos_x << endl;
}
int main() {
input();
knap();
solve();
}
|
#include <bits/stdc++.h>
int n, k, i, j, p, z, a[1010], b[1010];
bool q, u[2010];
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
u[0] = true;
for (i = 1; i <= n; i++)
if (a[i] == 0) {
q = false;
for (p = i, j = 1; p != 0; j++, p = b[p])
if (p == k) {
q = true;
z = j;
}
if (!q)
for (int i = n; i >= 0; i--)
if (u[i]) u[i + j - 1] = true;
}
for (i = 0; i <= n; i++)
if (u[i]) printf("%d\n", i + z);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_a = 1002;
int n, x;
int a[max_a];
int b[max_a];
int b_len = 0;
int visited[max_a] = {0};
int root[max_a] = {0};
bool count_offset = false;
int offset = 0;
void visit(int k, int w) {
visited[k] = true;
if (count_offset) offset++;
if (k == x) count_offset = true;
if (a[k] == -1) {
if (!count_offset) {
b[b_len] = w;
b_len++;
}
} else {
visit(a[k], w + 1);
}
}
bool answer[max_a][max_a];
int main() {
cin >> n >> x;
x--;
for (int i = 0; i < n; i++) root[i] = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
if (a[i] != -1) {
root[a[i]] = 0;
}
}
for (int i = 0; i < n; i++) {
count_offset = false;
if (!visited[i] && root[i]) {
visit(i, 1);
}
}
if (b_len == 0) {
printf("%d\n", offset + 1);
return 0;
}
for (int i = 0; i <= b_len; i++) answer[0][i] = 1;
for (int i = 0; i <= n; i++)
for (int j = 1; j <= b_len; j++) {
answer[i][j] = answer[i][j - 1];
if (i >= b[j - 1])
answer[i][j] = answer[i][j] || answer[i - b[j - 1]][j - 1];
}
for (int i = 0; i <= n; i++) {
if (answer[i][b_len]) printf("%d\n", i + offset + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int was[1111], pr[1111], l[1111], ln = 0, dep[1111], tail[1111], f[1111];
int n, x, add = 0;
int dfs(int x) {
if (x == 0) return 0;
was[x] = true;
return dep[x] = dfs(pr[x]) + 1;
}
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) {
scanf("%d", &pr[i]);
tail[pr[i]] = true;
}
for (int i = 1; i <= n; ++i)
if (!tail[i]) {
bool clev = (dep[x] == 0);
dfs(i);
if (clev && dep[x] != 0) {
add = dep[x];
} else {
l[ln++] = dep[i];
}
}
f[0] = 1;
for (int i = 0; i < ln; ++i) {
for (int j = n; j >= l[i]; j--) f[j] |= f[j - l[i]];
}
for (int i = 0; i <= n; ++i) {
if (f[i]) {
cout << i + add << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
bool byl;
bool ref;
int prev;
};
Node nodes[1100];
vector<int> delky;
bool cansize[3300];
int main() {
int N, X;
scanf("%d%d", &N, &X);
--X;
int ixoff;
for (int i = 0; i < N; ++i) {
scanf("%d", &nodes[i].prev);
nodes[i].prev--;
nodes[nodes[i].prev].ref = true;
}
for (int i = 0; i < N; ++i) {
if (!nodes[i].ref) {
int curr = i;
int len = 1;
bool isix = false;
if (curr == X) {
isix = true;
ixoff = 0;
}
while (nodes[curr].prev != -1) {
curr = nodes[curr].prev;
len++;
if (isix) ixoff++;
if (curr == X) {
isix = true;
ixoff = 0;
}
}
if (!isix) {
delky.push_back(len);
}
}
}
cansize[0] = 1;
for (int i = 0; i < delky.size(); ++i) {
for (int j = N + 1 - delky[i]; j >= 0; --j) {
if (cansize[j]) {
cansize[j + delky[i]] = true;
}
}
}
for (int i = 0; i < N; ++i) {
if (cansize[i]) {
printf("%d\n", i + ixoff + 1);
}
}
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);
}
}
set<long long> res;
void subsetSums(long long arr[], long long n) {
long long total = 1 << n;
for (long long i = 0; i < total; i++) {
long long sum = 0;
for (long long j = 0; j < n; j++)
if (i & (1 << j)) sum += arr[j];
res.insert(sum + pos);
}
}
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 c : cl) memo |= memo << c;
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 n, m;
int a[1005];
bool used[1005];
int b[1005];
int kol, kol2;
vector<int> v[1005];
void dfs(int x) {
used[x] = true;
++kol2;
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i];
if (used[to] == false) dfs(to);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i]) {
v[i].push_back(a[i]);
v[a[i]].push_back(i);
}
}
int kol = 0;
int z = m;
while (z) {
++kol;
z = a[z];
}
int kol3 = kol;
kol = 0;
dfs(m);
for (int i = 1; i <= n; ++i)
if (used[i] == false) {
kol2 = 0;
dfs(i);
b[++kol] = kol2;
}
for (int i = 0; i <= n; ++i) used[i] = false;
used[0] = true;
for (int i = 1; i <= kol; ++i) {
for (int j = n; j >= b[i]; --j)
if (used[j - b[i]]) used[j] = true;
}
for (int i = 0; i <= n; ++i)
if (used[i]) cout << i + kol3 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 10;
const int mod = (int)1e9;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
vector<int> G[1005];
int n, m, color[1005], fn[1005], cnt = 0, nxt[1005], flg = 0;
vector<int> v;
priority_queue<int, vector<int>, greater<int> > vc;
void DFS_Visit(int u) {
if (u == m) {
flg = 1;
}
int i, v, l;
cnt++;
color[u] = 1;
l = G[u].size();
for (i = 0; i < l; i++) {
v = G[u][i];
if (color[v] == 0) {
DFS_Visit(v);
}
}
}
void DFS() {
int i;
for (i = 1; i <= n; i++)
if (color[i] == 0) {
flg = 0;
cnt = 0;
DFS_Visit(i);
if (flg == 0) v.push_back(cnt);
}
}
int l;
int dp[1005][1005], cn = 0;
void call(int i, int sz) {
if (cnt >= cn) return;
if (dp[sz][i] != -1) return;
for (int j = i; j < l; j++) {
if (fn[sz + v[j]] == 0) {
vc.push(sz + v[j]);
fn[sz + v[j]] = 1;
cnt++;
}
call(j + 1, sz + v[j]);
}
dp[sz][i] = 1;
}
int main() {
memset(dp, -1, sizeof(dp));
int i, x, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
nxt[i] = x;
if (x > 0) {
nxt[i] = x;
G[i].push_back(x);
G[x].push_back(i);
}
cn++;
}
DFS();
i = 1;
while (nxt[m]) {
i++;
j = m;
m = nxt[m];
nxt[j] = 0;
}
l = v.size();
vc.push(i);
fn[i] = 1;
cnt = 1;
call(0, i);
while (!vc.empty()) {
int a = vc.top();
vc.pop();
printf("%d\n", a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, x, nums, num[10000], qq[10000], deep[10000], q, cn[10000], sz[10000],
usd[10000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> x;
nums = 0;
for (int i = 1; i <= n; i++) {
cin >> qq[i];
q = qq[i];
if (q == 0) {
num[i] = nums + 1;
nums++;
sz[nums] = 1;
deep[i] = 1;
}
if (i == x) usd[num[i]] = 1;
}
for (int iter = 1; iter <= 1000; iter++)
for (int i = 1; i <= n; i++)
if (deep[qq[i]] > 0 && deep[i] == 0) {
q = qq[i];
num[i] = num[q];
sz[num[i]]++;
deep[i] = deep[q] + 1;
if (i == x) usd[num[i]] = 1;
}
cn[deep[x]] = 1;
for (int i = 1; i <= nums; i++)
if (usd[i] == 0)
for (int j = 1000; j >= 0; --j)
if (cn[j]) cn[j + sz[i]] = 1;
for (int i = 1; i <= 1000; i++)
if (cn[i]) cout << i << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sudah[444];
int depan[50000];
int blkg[50000];
int knap[4000];
int main() {
int n, x;
cin >> n >> x;
--x;
for (int(i) = 0; (i) < (n); ++(i)) cin >> depan[i];
for (int(i) = 0; (i) < (n); ++(i)) blkg[i] = -1;
for (int(i) = 0; (i) < (n); ++(i)) {
depan[i] -= 1;
if (depan[i] >= 0) blkg[depan[i]] = i;
}
vector<int> sequences;
for (int(i) = 0; (i) < (n); ++(i))
if (blkg[i] == -1) {
int len = 1;
int ok = (i != x);
int j = i;
while (depan[j] != -1) {
++len;
j = depan[j];
if (j == x) ok = 0;
}
if (!ok) continue;
sequences.push_back(len);
}
int init_len = 1;
int p = x;
while (depan[p] != -1) {
p = depan[p];
init_len += 1;
}
knap[init_len] = 1;
for (typeof((sequences).begin()) it = (sequences).begin();
it != (sequences).end(); it++) {
for (int jum = n + 1; jum >= 1; --jum) {
knap[jum + *it] |= knap[jum];
}
}
for (int i = 1; i <= n; ++i)
if (knap[i]) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int following[1005];
int queueLength[1005];
int okQueue[1005];
int main() {
int n, k;
cin >> n >> k;
int head = k, shift = 1, tmp;
for (int i = 1; i <= n; i++) {
cin >> following[i];
queueLength[i]++;
tmp = i;
while (following[tmp] != 0) {
queueLength[following[tmp]] += queueLength[i];
tmp = following[tmp];
}
}
while (following[head]) {
head = following[head];
shift++;
}
vector<int> queues;
for (int i = 1; i <= n; i++) {
if (following[i] == 0 && i != head) {
queues.push_back(queueLength[i]);
}
}
sort(queues.begin(), queues.end());
okQueue[0] = 1;
for (unsigned i = 0; i < queues.size(); i++) {
for (int j = n - queues[i]; j >= 0; j--) {
if (okQueue[j]) {
okQueue[j + queues[i]] = 1;
}
}
}
for (int i = 0; i < n; i++) {
if (okQueue[i]) printf("%d\n", i + shift);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 86;
int f[MAXN];
int e[MAXN];
int n, x;
int p = -1;
int tot;
vector<int> head;
vector<int> c;
vector<int> out;
void dfs(int r, int d) {
if (r == x) p = d;
++tot;
if (e[r] != -1) dfs(e[r], d + 1);
}
int main() {
scanf("%d%d", &n, &x);
memset(e, -1, sizeof(e));
for (int i = 1, j; i <= n; ++i) {
scanf("%d", &j);
if (j == 0)
head.push_back(i);
else
e[j] = i;
}
int m = head.size(), cc = 0;
for (int i = 0; i < m; ++i) {
tot = 0;
dfs(head[i], 1);
if (p != -1)
cc = p, p = -1;
else
c.push_back(tot);
}
sort(c.begin(), c.end());
f[0] = 1;
for (int i = 0; i < c.size(); ++i) {
for (int k = MAXN - 1; k >= 0; --k)
if (f[k]) {
f[k + c[i]] = 1;
}
}
for (int i = 0; i < MAXN; ++i)
if (f[i]) out.push_back(i + cc);
sort(out.begin(), out.end());
for (int i = 0; i < out.size(); ++i) printf("%d\n", out[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n;
int x;
int a[3270];
int used[3270];
int dp[3270];
int bplace = -1;
int plc;
void input();
void solve();
void f(int vertex);
int main() {
input();
solve();
return 0;
}
void input() {
scanf("%d%d", &n, &x);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
}
void solve() {
int i, j;
int lstplc;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (a[j] == i) break;
}
plc = 0;
lstplc = bplace;
if (used[i] == 0 && j == n + 1) {
f(i);
if (bplace != -1 && lstplc == -1) {
bplace = plc - bplace + 1;
continue;
}
v.push_back(plc);
}
}
dp[0] = 1;
int m = v.size();
for (i = 0; i < m; i++) {
for (j = 0; j <= n; j++) {
if (dp[j] == 1 && dp[j + v[i]] == 0) {
dp[j + v[i]] = 2;
}
}
for (j = 0; j <= n; j++) {
if (dp[j] == 2) dp[j] = 1;
}
}
for (i = 0; i <= n; i++) {
if (dp[i] == 1) printf("%d\n", i + bplace);
}
}
void f(int vertex) {
plc++;
used[vertex] = 1;
if (vertex == x) {
bplace = plc;
}
if (a[vertex] == 0) return;
f(a[vertex]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[1010];
bool f0[2][1010], d[1010], *f, *g;
int main() {
scanf("%d%d", &n, &k);
k--;
memset(a, -1, sizeof a);
for (int i = 0; i < n; i++) scanf("%d", a + i), a[i]--, d[a[i]] = 1;
f = f0[0], g = f0[1];
f[0] = 1;
int bf = 0;
for (int i = 0; i < n; i++)
if (!d[i]) {
int s = 0;
bool F = 0;
for (int j = i; j != -1; j = a[j]) {
s++;
if (j == k) F = 1;
}
if (F) {
for (int j = k; j != -1; j = a[j]) bf++;
continue;
}
for (int j = 0; j < n; j++) g[j] = 0;
for (int j = 0; j < n; j++)
if (f[j]) g[j] = 1, g[j + s] = 1;
swap(f, g);
}
for (int i = 0; i < n; i++)
if (f[i]) printf("%d\n", i + bf);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int big = 2000000000;
const double INF = 1e9;
const double EPS = 1e-9;
int par[1002];
int idx[1002];
int sz[1002];
int get_par(int x) {
if (par[x] == x) {
idx[x] = 1;
return x;
}
int t = par[x];
par[x] = get_par(par[x]);
if (idx[x] == -1) idx[x] = idx[t] + 1;
if (0) printf(">> %d %d %d %d\n", x, t, par[x], idx[x]);
return par[x];
}
int main() {
int n, q;
memset((idx), -1, sizeof(idx));
scanf("%d%d", &n, &q);
--q;
for (int x = 0, _c = n; x < _c; ++x) {
scanf("%d", &par[x]);
--par[x];
if (par[x] == -1) par[x] = x;
}
set<int> blok;
for (int x = 0, _c = n; x < _c; ++x) {
if (idx[x] == -1) blok.insert(get_par(x));
++sz[par[x]];
}
blok.erase(par[q]);
if (0) printf(">");
for (int x = 0, _c = n; x < _c; ++x)
if (0) printf(" %d", idx[x]);
if (0) printf("\n");
for (__typeof((blok).begin()) it = (blok).begin(); it != (blok).end(); ++it)
if (0) printf("> %d %d\n", *it, sz[*it]);
bool dp[1002];
memset((dp), 0, sizeof(dp));
dp[idx[q]] = true;
for (__typeof((blok).begin()) it = (blok).begin(); it != (blok).end(); ++it)
for (int x = n, _c = sz[*it]; x >= _c; --x)
if (dp[x - sz[*it]]) dp[x] = true;
for (int x = 0, _c = n + 1; x < _c; ++x)
if (dp[x]) printf("%d\n", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int a[N];
int n, x;
vector<int> za[N];
int deg[N];
vector<int> dls;
int bPos;
bool F[N];
int main() {
scanf("%d %d", &n, &x);
for (int i = 0; i < (n); ++i) {
scanf("%d", &a[i + 1]);
++deg[a[i + 1]];
}
for (int i = 1; i <= (n); ++i) {
if (deg[i] == 0) {
int cur = i;
int dl = 0;
int posX = -1;
while (a[cur] != 0) {
if (cur == x) posX = dl;
++dl;
cur = a[cur];
}
if (cur == x) posX = dl;
++dl;
if (posX != -1) {
bPos = dl - posX;
} else {
dls.push_back(dl);
}
}
}
F[0] = true;
for (typeof((dls).begin()) p = ((dls).begin()); p != (dls).end(); ++p) {
for (int i = n; i >= (*p); --i) F[i] |= F[i - *p];
}
for (int i = 0; i < (n + 1); ++i)
if (F[i]) printf("%d\n", i + bPos);
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000007; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m, q;
int A[1012];
int AA[1012];
int R[1012];
int main() {
int i, j, k;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
scanf(
"%"
"d",
&(k));
--k;
for (i = (0); i < (n); ++i) A[i] = AA[i] = -1;
for (i = (0); i < (n); ++i) {
scanf(
"%"
"d",
&(a));
--a;
A[i] = a;
if (a >= 0) AA[a] = i;
}
for (i = (0); i < (n); ++i) R[i] = 0;
int res = 0;
for (; A[k] >= 0; k = A[k]) ++res;
R[res] = 1;
for (i = (0); i < (n); ++i)
if (i != k && A[i] < 0) {
for (a = 1, j = i; AA[j] >= 0; j = AA[j]) ++a;
for (j = (n)-1; j >= (0); --j)
if (R[j]) R[j + a] = 1;
}
for (i = (0); i < (n); ++i)
if (R[i])
printf(
"%"
"d",
(i + 1)),
printf("\n"), firstout = 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ad[2009];
int vis[2009];
int cnt;
vector<int> cp;
int p, X;
void dfs(int u) {
vis[u] = 1;
cnt++;
if (u == X) p = 1;
for (auto x : ad[u]) {
if (vis[x]) continue;
dfs(x);
}
}
int dp[20009];
int main() {
int i, j, k, l, m, n, x;
cin >> n >> x;
X = x;
int br[n + 10];
for (i = 1; i <= n; i++) {
cin >> l;
br[i] = l;
if (l == 0) continue;
ad[l].push_back(i);
ad[i].push_back(l);
}
p = 0;
int ex;
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
cnt = 0;
dfs(i);
if (!p)
cp.push_back(cnt);
else
ex = cnt, p = 0;
}
}
ex = 1;
while (br[x] != 0) {
x = br[x];
ex++;
}
for (i = 1; i <= n; i++) dp[i] = 1e9;
dp[0] = 0;
for (j = 0; j < cp.size(); j++) {
for (i = n - ex; i >= 1; i--) {
if (cp[j] <= i) dp[i] = min(dp[i], 1 + dp[i - cp[j]]);
}
}
cout << ex << '\n';
for (i = 1; i <= n - ex; i++) {
if (dp[i] != 1e9) {
cout << i + ex << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int last[1010], c[1010], n, x;
int a[1010], m;
bool ex[1010];
int main() {
int i, j, pos, tt;
while (~scanf("%d%d", &n, &x)) {
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
m = 0;
for (i = 0; i <= n; i++) last[i] = -1;
for (i = 1; i <= n; i++) {
if (c[i] == 0) continue;
last[c[i]] = i;
}
for (i = 1; i <= n; i++) {
if (c[i] != 0) continue;
j = i;
c[j] = ++m;
int t = 1;
if (x == j) pos = t;
while (last[j] != -1) {
j = last[j];
c[j] = m;
t++;
if (x == j) pos = t;
}
}
for (i = 0; i <= m; i++) a[i] = 0;
for (i = 1; i <= n; i++) a[c[i]]++;
for (i = 0; i <= 1000; i++) ex[i] = 0;
ex[0] = 1;
for (j = 1; j <= m; j++) {
if (j == c[x]) continue;
for (i = n; i >= 1; i--) {
if (i - a[j] < 0) break;
ex[i] |= ex[i - a[j]];
}
}
for (i = 0; i <= n; i++)
if (ex[i]) printf("%d\n", i + pos);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
int n, x;
int a[MAXN];
int father[MAXN];
int len[MAXN];
bool visit[MAXN];
void init() {
for (int i = 1; i <= n; ++i) {
father[i] = i;
len[i] = 1;
}
}
int find(int x) {
if (x == father[x]) {
return x;
}
return father[x] = find(father[x]);
}
void combine(int x, int y) {
x = find(x);
y = find(y);
father[x] = y;
len[y] += len[x];
len[x] = 0;
}
int main() {
while (~scanf("%d%d", &n, &x)) {
init();
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i]) {
if (find(i) != find(a[i])) {
combine(i, a[i]);
}
}
}
int shift = 1;
int temp = x;
while (a[temp]) {
++shift;
temp = a[temp];
}
memset(visit, false, sizeof(visit));
visit[0] = true;
for (int i = 1; i <= n; ++i) {
if (len[i]) {
if (find(x) == find(i)) {
continue;
}
for (int j = n; j >= len[i]; --j) {
if (visit[j - len[i]]) {
visit[j] = true;
}
}
}
}
for (int i = 0; i < n; ++i) {
if (visit[i]) {
printf("%d\n", i + shift);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rdi() {
int d;
scanf("%d", &d);
return d;
}
inline char rdc() {
scanf(" ");
return getchar();
}
inline string rds() {
string s;
cin >> s;
return s;
}
inline double rddb() {
double d;
scanf("%lf", &d);
return d;
}
template <class T>
inline bool updateMin(T& a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool updateMax(T& a, T b) {
return a < b ? a = b, true : false;
}
const int N = 1024;
bool dp[N] = {true};
vector<int> v, ans;
int n, x, f[N], cnt[N], pre[N];
void init_UFS() {
for (int i = (1); i <= (n); ++i) {
f[i] = rdi();
if (!f[i]) f[i] = i;
}
}
int root(int x) {
if (f[x] == x) {
pre[x] = 1;
return x;
}
int fx = f[x];
f[x] = root(fx);
if (!pre[x]) pre[x] = pre[fx] + 1;
return f[x];
}
int main() {
cin >> n >> x;
init_UFS();
for (int i = (1); i <= (n); ++i) ++cnt[root(i)];
int rx = root(x);
for (int i = (1); i <= (n); ++i)
if (f[i] == i && i != rx) v.push_back(cnt[i]);
int sum = 0;
for (int i_b = (((int)(v).size())), i = (0); i < i_b; ++i) {
for (int j = (sum); j >= (0); --j)
if (dp[j]) dp[j + v[i]] = true;
sum += v[i];
}
for (int i = (0); i < (N); ++i)
if (dp[i]) ans.push_back(i + pre[x]);
for (int i_b = (((int)(ans).size())), i = (0); i < i_b; ++i)
printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long father[1010], tot[1010], s[1010];
bool f[1010];
long n, x, t, tots;
long find(const long h) {
if (father[h] == h)
return h;
else
return find(father[h]);
}
int main() {
int i;
cin >> n >> x;
for (i = 1; i <= n; i++) {
father[i] = i;
tot[i] = 1;
}
for (i = 1; i <= n; i++) {
cin >> t;
if (t != 0) {
father[i] = t;
tot[find(i)] += tot[i];
}
}
tot[find(x)] = 0;
for (i = 1; i <= n; i++)
if (father[i] == i) s[++tots] = tot[i];
i = x;
t = 1;
while (father[i] != i) {
i = father[i];
t++;
}
memset(f, 0, sizeof(f));
f[t] = true;
for (i = 1; i <= tots; i++) {
for (long j = n; j >= s[i]; j--) {
f[j] = f[j] || f[j - s[i]];
}
}
for (int i = 1; i <= n; i++)
if (f[i]) cout << i << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int n, m, a[N], cur, b[N];
bool used[N];
void dfs(int v) {
cur++;
if (a[v]) {
dfs(a[v]);
}
}
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];
if (a[i]) {
b[a[i]] = i;
}
}
bitset<N> dp;
dfs(m);
dp[cur] = true;
int z = m;
while (z > 0) {
int x = b[z];
b[z] = N;
z = x;
}
for (int i = 1; i <= n; i++) {
if (!b[i]) {
cur = 0;
dfs(i);
dp |= (dp << cur);
}
}
for (int i = 1; i < N; i++) {
if (dp[i]) {
cout << i << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A>
ostream& output(ostream& out, A a, A b) {
if (a == b) return out;
out << *a;
while (++a != b) out << ' ' << *a;
return out;
}
template <class A>
ostream& operator<<(ostream& out, const vector<A>& v) {
return output(out, v.begin(), v.end());
}
int a[1005], dep[1005], mark[1005];
bool dp[1005];
void dfs(int n) {
if (!n) return;
if (mark[n]) return;
mark[n] = true;
dfs(a[n]);
}
int main() {
int n, x;
while (2 == scanf("%d%d", &n, &x)) {
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
a[i] = x;
}
memset(mark, 0, sizeof mark);
memset(dep, 0, sizeof dep);
memset(dp, 0, sizeof dp);
for (int i = 1; i <= n; ++i) {
dfs(a[i]);
}
int base = 0;
dp[0] = true;
for (int i = 1; i <= n; ++i) {
if (!mark[i]) {
int j = i, c = 0, b = false;
while (true) {
++c;
if (j == x) {
c = 0;
b = true;
}
j = a[j];
if (!j) break;
}
if (b) {
base = c;
continue;
}
for (int j = n; j >= c; --j) {
dp[j] = dp[j] || dp[j - c];
}
}
}
(std::cerr << "base"
<< ": " << (base) << std::endl);
for (int i = 0; i < n; ++i) {
if (dp[i]) printf("%d\n", i + base + 1);
}
}
}
|
#include <bits/stdc++.h>
const int MAXN = 100002;
using namespace std;
int stringtoint(string s) {
if (s.empty()) {
return -1;
}
istringstream iss(s);
int i;
iss >> i;
return i;
}
int main() {
int n, x;
cin >> n >> x;
x--;
vector<int> prev(n);
vector<int> next(n);
for (int i = 0; i < n; i++) next[i] = -1;
vector<int> st;
vector<int> siz;
int smst;
for (int i = 0; i < n; i++) {
cin >> prev[i];
prev[i]--;
if (prev[i] >= 0)
next[prev[i]] = i;
else {
st.push_back(i);
siz.push_back(0);
}
}
for (int i = 0; i < st.size(); i++) {
int temp = st[i];
if (temp == x) smst = i;
siz[i]++;
while (next[temp] != -1) {
temp = next[temp];
siz[i]++;
if (temp == x) smst = i;
}
}
int smsiz = 1;
for (int temp = st[smst]; temp != x; temp = next[temp]) {
smsiz++;
}
vector<int> qs;
for (int i = 0; i < st.size(); i++) {
if (i != smst) qs.push_back(siz[i]);
}
sort(qs.begin(), qs.end());
vector<vector<bool> > dp(1002);
for (int i = 0; i < dp.size(); i++) dp[i].resize(1002);
dp[0][0] = 1;
for (int i = 1; i <= qs.size(); i++) {
for (int j = 0; j < dp[i].size(); j++) {
dp[i][j] =
(dp[i - 1][j]) || (j - qs[i - 1] >= 0 && (dp[i - 1][j - qs[i - 1]]));
}
}
for (int i = 0; i < dp[qs.size()].size(); i++) {
if (dp[qs.size()][i]) cout << i + smsiz << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int f[1005], v[1005], pr[1005], x, cc = 0, cont = 0, cate[1005], contor = 0,
sume[1005], sumi, rucsac[1005];
void dfs(int nod) {
if (v[nod] != 0) {
pr[v[nod]] = nod;
if (f[v[nod]] == 0) {
f[v[nod]] = 1;
dfs(v[nod]);
}
}
}
void anti_dfs(int nod) {
if (nod == 0) {
return;
}
if (nod == x) cc = 1;
cont++;
anti_dfs(pr[nod]);
cate[nod] = cate[pr[nod]] + 1;
}
int main() {
int n;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
for (int i = 1; i <= n; i++) {
if (v[i] != 0 and f[i] == 0) {
f[i] = 1;
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
if (v[i] == 0) {
anti_dfs(i);
if (cc == 1) {
sumi = cate[i] - cate[x] + 1;
} else {
sume[++contor] = cate[i];
}
cc = 0;
cont = 0;
}
}
rucsac[0] = 1;
for (int i = 1; i <= contor; i++) {
for (int j = n; j >= 0; j--) {
if (rucsac[j] == 1) {
rucsac[j + sume[i]] = 1;
}
}
}
for (int i = 0; i <= n; i++) {
if (rucsac[i] == 1) {
cout << i + sumi << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
int a[1001];
bool hasPred[1001] = {};
cin >> n >> x;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] != 0) {
hasPred[a[i]] = true;
}
}
int lengths[1000];
int size = 0;
for (int i = 1; i <= n; ++i) {
if (!hasPred[i] && i != x) {
lengths[size] = 0;
bool metX = false;
for (int j = i; j != 0; j = a[j]) {
++lengths[size];
metX |= j == x;
}
if (!metX) {
++size;
}
}
}
int pos = 0;
for (int i = x; i != 0; i = a[i]) {
++pos;
}
bool possible[1000] = {};
possible[0] = true;
for (int i = 0; i < size; ++i) {
for (int j = n - 1; j > 0; --j) {
if (j >= lengths[i]) {
possible[j] |= possible[j - lengths[i]];
}
}
}
for (int i = 0; i < n; ++i) {
if (possible[i]) {
cout << i + pos << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, size[12000], b[12000], a[12000], num, fa[12000], j;
int get(int x) { return fa[x] == x ? x : (fa[x] = get(fa[x])); }
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) fa[i] = i;
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i]) fa[i] = a[i];
}
for (i = 1; i <= n; ++i) size[get(i)]++;
b[0] = 1;
for (i = 1; i <= n; ++i)
if (get(i) == i && get(m) != get(i))
for (j = n - size[i]; j >= 0; --j) b[j + size[i]] |= b[j];
for (i = m; i; i = a[i]) num++;
for (i = 0; i <= n; ++i)
if (b[i]) printf("%d\n", i + num);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
int pre[1100];
int net[1100];
bool hah[1100];
vector<int> val;
int main() {
while (cin >> n >> x) {
memset(pre, -1, sizeof(pre));
memset(net, -1, sizeof(net));
memset(hah, false, sizeof(hah));
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
if (a != 0) {
pre[i] = a;
net[a] = i;
}
}
val.clear();
for (int i = 1; i <= n; i++) {
if (pre[i] == -1) {
int ct = 0;
int a = i;
bool f = true;
while (a != -1) {
if (a == x) {
f = false;
}
ct++;
a = net[a];
}
if (f == true) {
val.push_back(ct);
}
}
}
sort(val.begin(), val.end());
hah[0] = true;
for (int i = 0; i < val.size(); i++) {
for (int j = n; j >= 0; j--) {
if (hah[j] == true) {
hah[j + val[i]] = true;
}
}
}
int n1 = 0;
int b = x;
while (b != -1) {
n1++;
b = pre[b];
}
for (int i = 0; i <= n; i++) {
if (hah[i] == true) {
printf("%d\n", n1 + i);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1001];
vector<int> firsts;
int calculateDistance(int currPos, int prev) {
if (adj[currPos].size() == 0) return 1;
if (adj[currPos].size() == 1 && prev != 0) return 1;
for (auto next : adj[currPos]) {
if (next != prev) return 1 + calculateDistance(next, currPos);
}
}
int findFirstQ(int curr, int prev) {
if (adj[curr].size() == 0) return curr;
if (adj[curr].size() == 1 && adj[curr][0] == prev) return curr;
for (auto next : adj[curr]) {
if (next != prev) return findFirstQ(next, curr);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
scanf("%d %d", &n, &x);
int a, prevSmartBeaver = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
if (a != 0) {
adj[i].push_back(a);
adj[a].push_back(i);
} else {
firsts.push_back(i);
}
if (a == x) prevSmartBeaver = i;
}
int distSmartBeaver = calculateDistance(x, prevSmartBeaver);
int firstElQSmartB = findFirstQ(x, prevSmartBeaver);
vector<int> lEachQ;
lEachQ.push_back(0);
for (auto v : firsts) {
if (v != firstElQSmartB) lEachQ.push_back(calculateDistance(v, 0));
}
sort(lEachQ.begin(), lEachQ.begin() + lEachQ.size());
bool possible[1001] = {false};
possible[0] = true;
for (int k = 1; k <= lEachQ.size() - 1; k++) {
for (int w = n; w >= 0; w--) {
if (possible[w]) possible[w + lEachQ[k]] = true;
}
}
for (int i = 0; i <= n; i++) {
if (possible[i]) cout << i + distSmartBeaver << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[1010];
int a[1010], in[1010];
int dp[1010];
int n, m, my;
int dfs(int x) {
int cnt = 1;
int u = x, k = 0;
if (u == m) k = 1;
while (pre[u] != u) {
++cnt;
u = pre[u];
if (u == m) k = 1;
}
if (k) {
int c = 1;
u = x;
while (u != m) {
++c;
u = pre[u];
}
my = cnt - c + 1;
return 0;
} else
return cnt;
}
int main() {
int x;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) pre[i] = i, in[i] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
if (x) pre[i] = x, ++in[x];
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (!in[i]) {
x = dfs(i);
if (x) a[cnt++] = x;
}
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < cnt; ++i)
for (int j = n; j - a[i] >= 0; --j)
if (dp[j - a[i]]) dp[j] = 1;
for (int i = 0; i <= n; ++i)
if (dp[i] && i + my <= n) printf("%d\n", i + my);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, x, z;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+') {
continue;
}
for (int j = 0; j < s.size(); j++) {
if (s[j] == '+') {
continue;
}
if (s[i] < s[j]) {
swap(s[j], s[i]);
}
}
}
for (int i = 0; i < s.size(); i++) {
cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = s.length();
int i;
int a = 0;
int b = 0;
int c = 0;
for (i = 0; i < l; i += 2) {
if (s[i] == '1') {
a++;
} else if (s[i] == '2') {
b++;
} else {
c++;
}
}
for (i = 0; i < a; i++) {
if ((b != 0) || (c != 0)) {
cout << "1+";
} else {
if (i == (a - 1)) {
cout << "1";
} else {
cout << "1+";
}
}
}
for (i = 0; i < b; i++) {
if (c != 0) {
cout << "2+";
} else {
if (i == (b - 1)) {
cout << "2";
} else {
cout << "2+";
}
}
}
for (i = 0; i < c; i++) {
if (i == (c - 1)) {
cout << "3";
} else {
cout << "3+";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
string p;
cin >> str;
int len = str.length();
for (int i = 0; i < len; i += 2)
for (int j = 0; j < len; j += 2)
if (str[i] < str[j]) {
swap(str[i], str[j]);
}
cout << str;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
string s, o = "";
vector<int> v;
cin >> s;
for (int i = 0; i < ((int)s.size()); i++)
if (s[i] != '+') v.push_back(s[i] - '0');
sort(v.begin(), v.end());
for (int i = 0; i < ((int)v.size()); i++) {
o += v[i] + '0';
o += '+';
}
o[((int)o.size()) - 1] = ' ';
cout << o << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1 = "";
cin >> s;
for (int i = 0; i < s.length(); i++)
if (s[i] != '+') s1.push_back(s[i]);
sort(s1.begin(), s1.end());
for (int i = 0; i < s1.length() - 1; i++) cout << s1[i] << '+';
cout << s1[s1.length() - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int temp;
int one = 0, two = 0, three = 0;
for (int i = 0; i < s.size(); i = i + 2) {
temp = (int)s[i] - 48;
if (temp == 1)
one++;
else if (temp == 2)
two++;
else
three++;
}
for (int i = 0; i < one; i++) {
cout << 1;
if (i != one - 1) cout << "+";
}
if (two > 0 && one > 0) cout << "+";
for (int i = 0; i < two; i++) {
cout << 2;
if (i != two - 1) cout << "+";
}
if (three > 0 && (one > 0 || two > 0)) cout << "+";
for (int i = 0; i < three; i++) {
cout << 3;
if (i != three - 1) cout << "+";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string in;
vector<int> v;
cin >> in;
stringstream ss(in);
while (ss >> t) {
v.push_back(t);
}
sort(v.begin(), v.end());
for (unsigned int i = 0; i < v.size(); i++) {
if (i != v.size() - 1) {
cout << v[i] << "+";
} else {
cout << v[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, x = 0;
char str[200] = {};
cin >> str;
int n = strlen(str), y = (n / 2 + 1);
int arr[n];
for (int i = 0; i < y; i++) {
arr[i] = ((int)str[x] - 48);
x += 2;
}
sort(arr, arr + y);
for (int i = 0; i < y; i++) {
if (i == 0)
cout << arr[0];
else
cout << "+" << arr[i];
}
return 0;
}
|
#include <bits/stdc++.h>
int diff(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int main() {
int len, i, index = 0, arr[1000];
char str[1000];
scanf("%s", str);
len = strlen(str);
i = 0;
while (i < len) {
arr[index++] = str[i] - '0';
i = i + 2;
}
qsort(arr, index, sizeof(int), diff);
for (i = 0; i < index - 1; i++) printf("%d+", arr[i]);
printf("%d\n", arr[index - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, num = 0, i;
vector<int> v;
string s1;
cin >> s1;
int l = s1.size();
for (int i = 0; i < l; i++) {
char c = s1[i];
if (c == '0' || c == '1' || c == '2' || c == '3' || c == '4' || c == '5' ||
c == '6' || c == '7' || c == '8' || c == '9') {
n = c - '0';
num = (num * 10) + n;
}
if (c == '+') {
v.push_back(num);
num = 0;
}
}
v.push_back(num);
int a = v.size();
int m = a - 1;
for (int i = 0; i < m; i++) {
if (v[i] > v[i + 1]) {
int f = v[i + 1];
v[i + 1] = v[i];
v[i] = f;
}
if (i == m - 1) {
i = -1;
m--;
}
}
for (int i = 0; i < a; i++)
if (i == 0)
cout << v[i];
else
cout << "+" << v[i];
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
vector<char> number;
int length, i;
char equation[100];
gets(equation);
length = strlen(equation);
for (i = 0; i < length; i += 2) {
number.push_back(equation[i]);
}
sort(number.begin(), number.end());
for (i = 0; i < number.size() - 1; i++) {
printf("%c+", number[i]);
}
printf("%c", number[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int a{0}, b{0}, c{0};
for (int i = 0; i < n.size(); i++) {
if (n[i] == '1') {
a++;
} else if (n[i] == '2') {
b++;
} else if (n[i] == '3') {
c++;
}
}
if (a + b + c > 1) {
if (b == 0 && c == 0) {
for (int i = 0; i < a - 1; i++) {
cout << '1' << '+';
}
} else {
for (int i = 0; i < a; i++) {
cout << '1' << '+';
}
}
if (c != 0) {
for (int i = 0; i < b; i++) {
cout << '2' << "+";
}
} else {
for (int i = 0; i < b - 1; i++) {
cout << '2' << "+";
}
}
for (int i = 0; i < c - 1; i++) {
cout << '3' << '+';
}
}
if (c != 0) {
cout << 3;
} else if (b != 0) {
cout << 2;
} else if (a != 0) {
cout << 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[105], n;
char s[105];
scanf("%s", s);
for (int i = 0, j = 0; i < strlen(s); i += 2, j++) a[j] = s[i] - 48, n = j;
n++;
sort(a, a + n);
for (int i = 0; i < n - 1; i++) printf("%d+", a[i]);
printf("%d", a[n - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[500];
int main() {
string s1;
cin >> s1;
int k = 0;
for (int i = 0; i < s1.length(); i++) {
if (s1.at(i) == '+')
continue;
else
arr[k++] = s1.at(i) - '0';
}
sort(arr, arr + k);
for (int i = 0; i < k; i++) {
if (i != k - 1)
printf("%d+", arr[i]);
else
printf("%d", arr[i]);
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<int> v;
for (int i = 0; i < s.length(); i += 2) {
v.push_back(s[i]);
}
string res;
sort(v.begin(), v.end());
for (int i = 0; i < v.size() - 1; i++) {
res.push_back(v[i]);
res.push_back('+');
}
res.push_back(v[v.size() - 1]);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string str;
vector<char> vec;
cin >> str;
for (long long int i = 0; i < str.length(); i++) {
if (str[i] == '1' || str[i] == '2' || str[i] == '3') vec.push_back(str[i]);
}
sort(vec.begin(), vec.end());
cout << vec[0];
vec.erase(vec.begin());
while (vec.size()) {
cout << "+" << vec[0];
vec.erase(vec.begin());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
string x, y;
cin >> x;
for (int i = 0; i < x.size(); i++) {
if (x[i] != '+') y += x[i];
}
sort(y.begin(), y.end());
for (int i = 0; i < y.size(); i++) {
if (i == y.size() - 1) {
cout << y[i];
break;
}
cout << y[i] << "+";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1 = 0, x2 = 0, x3 = 0, x = 0;
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '1')
++x1;
else if (str[i] == '2')
++x2;
else if (str[i] == '3')
++x3;
else if (str[i] == '+')
++x;
else
return 0;
}
while (x1) {
cout << "1";
--x1;
if (x) cout << "+";
--x;
}
while (x2) {
cout << "2";
--x2;
if (x) cout << "+";
--x;
}
while (x3) {
cout << "3";
--x3;
if (x) cout << "+";
--x;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100], t[100];
char lib[3] = {'1', '2', '3'};
int c, m = 0;
cin >> s;
c = strlen(s);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < c; j++) {
if (s[j] == lib[i]) {
t[m] = lib[i];
m++;
t[m] = '+';
m++;
}
}
}
for (int i = 0; i < c; i++) {
if (i == (c - 1))
cout << t[i] << endl;
else
cout << t[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000];
scanf("%d", &a[0]);
int i = 1;
while (scanf("+%d", &a[i]) == 1) i++;
sort(&a[0], &a[i]);
printf("%d", a[0]);
for (int j = 1; j < i; j++) printf("+%d", a[j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int no1 = 0, no2 = 0, no3 = 0, nop = 0;
cin >> s;
int i;
for (i = 0; i < s.length(); i++) {
if (s[i] == '1') no1++;
if (s[i] == '2') no2++;
if (s[i] == '3') no3++;
if (s[i] == '+') nop++;
}
for (i = 0; i < no1; i++) {
cout << "1";
if (nop > 0) {
cout << "+";
nop--;
}
}
for (i = 0; i < no2; i++) {
cout << "2";
if (nop > 0) {
cout << "+";
nop--;
}
}
for (i = 0; i < no3; i++) {
cout << "3";
if (nop > 0) {
cout << "+";
nop--;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.