text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int v[500000];
int ans[500000];
queue<pair<int, int> > q;
vector<pair<int, int> > p[500000];
int main() {
int n, k, d, x, y;
int i, j;
cin >> n >> k >> d;
for (i = 0; i < k; i++) {
cin >> x;
q.push(make_pair(x, 0));
}
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
p[x].push_back(make_pair(y, i + 1));
p[y].push_back(make_pair(x, i + 1));
}
while (!(q.empty())) {
int l, r;
l = q.front().first;
r = q.front().second;
q.pop();
if (v[l] == 1) continue;
v[l] = 1;
for (i = 0; i < p[l].size(); i++) {
if (p[l][i].first != r) {
if (v[p[l][i].first] == 1)
ans[p[l][i].second] = 1;
else
q.push(make_pair(p[l][i].first, l));
}
}
}
int c = 0;
for (i = 1; i <= n - 1; i++) {
if (ans[i]) c++;
}
cout << c << endl;
for (i = 1; i <= n - 1; i++) {
if (ans[i]) cout << i << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, x, y, dis[300005], vis[300005], us[300005];
queue<pair<int, int> > q;
vector<pair<int, int> > E[300005];
vector<int> v;
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= n; i++) dis[i] = 1000000007;
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
q.push({x, 0});
dis[x] = 0;
}
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
E[x].push_back({y, i});
E[y].push_back({x, i});
}
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
q.pop();
if (vis[x] == 1) continue;
vis[x] = 1, us[y] = 1;
for (auto i : E[x]) {
if (dis[i.first] > dis[x] + 1) {
dis[i.first] = dis[x] + 1;
q.push({i.first, i.second});
}
}
}
for (int i = 1; i <= n - 1; i++)
if (!us[i]) v.push_back(i);
printf("%d\n", int(v.size()));
for (auto i : v) {
printf("%d ", i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 5;
bool visited[MAX];
int dist[MAX];
vector<pair<int, int> > adjList[MAX];
queue<pair<int, int> > q;
set<int> printed;
int main() {
int n, k, d;
scanf("%d %d %d", &n, &k, &d);
int v1, v2;
memset(dist, -1, sizeof(dist));
for (int i = 0; i < k; i++) {
scanf("%d", &v1);
q.push(make_pair(v1, 0));
}
for (int i = 1; i < n; i++) {
scanf("%d %d", &v1, &v2);
adjList[v1].push_back(make_pair(v2, i));
adjList[v2].push_back(make_pair(v1, i));
}
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
if (visited[u.first]) continue;
visited[u.first] = 1;
for (int i = 0; i < adjList[u.first].size(); i++) {
pair<int, int> t = adjList[u.first][i];
if (t.first != u.second) {
if (visited[t.first])
printed.insert(t.second);
else {
q.push(make_pair(t.first, u.first));
}
}
}
}
printf("%lu\n", printed.size());
for (auto it = printed.begin(); it != printed.end(); it++) {
if (it != printed.begin()) putchar(' ');
printf("%d", *it);
}
if (printed.size() > 0) putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, k, dis[300005];
vector<int> ans;
bool vis[300005], p[300003];
vector<int> all;
vector<pair<int, int> > e[300005];
void dfs(int idx, int cur) {
if (vis[idx]) {
return;
}
vis[idx] = 1;
for (int i = 0; i < e[idx].size(); i++) {
int to = e[idx][i].first;
if (!vis[to]) {
if (p[to]) {
ans.push_back(e[idx][i].second);
dfs(to, 0);
continue;
} else {
if (cur + 1 > dis[to]) {
ans.push_back(e[idx][i].second);
continue;
}
dfs(to, cur + 1);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
int foo;
queue<int> q;
fill(dis, dis + n + 1, 1e9);
for (int i = 0; i < k; i++) {
scanf("%d", &foo);
p[foo] = 1;
dis[foo] = 0;
all.push_back(foo);
}
for (int i = 0; i <= n; i++) {
if (p[i]) {
q.push(i);
}
}
int a, b;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
e[a].push_back(make_pair(b, i));
e[b].push_back(make_pair(a, i));
}
while (!q.empty()) {
int f = q.front();
q.pop();
for (int i = 0; i < e[f].size(); i++) {
int to = e[f][i].first;
if (dis[to] > dis[f] + 1) {
dis[to] = dis[f] + 1;
q.push(to);
}
}
}
for (int i = 0; i < all.size(); i++) {
dfs(all[i], 0);
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
if (i) {
printf(" ");
}
printf("%d", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_K = 3e5 + 5;
const int MAX_N = 3e5 + 5;
struct Road {
int to, index;
} rd;
int n, k, d;
int p[MAX_K], vis[MAX_N];
vector<Road> G[MAX_N];
vector<int> ans;
void BFS() {
queue<int> que;
for (int i = 1; i <= k; i++) {
if (vis[p[i]] != 0) continue;
vis[p[i]] = p[i];
que.push(p[i]);
}
int u, size;
while (!que.empty()) {
u = que.front();
que.pop();
size = G[u].size();
for (int i = 0; i < size; i++) {
rd = G[u][i];
if (vis[rd.to] == 0) {
vis[rd.to] = vis[u];
que.push(rd.to);
} else {
if (vis[rd.to] != vis[u]) {
ans.push_back(rd.index);
}
}
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
int cnt = ans.size();
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) {
printf("%d%c", ans[i], i == cnt - 1 ? '\n' : ' ');
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= k; i++) {
scanf("%d", &p[i]);
}
int u, v;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
rd.to = v;
rd.index = i;
G[u].push_back(rd);
rd.to = u;
rd.index = i;
G[v].push_back(rd);
}
BFS();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, k, d;
queue<pair<int, int> > q;
int h[N], e[N << 1], ne[N << 1], idx;
int num[N];
int u[N], v[N];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
void bfs() {
int x, y;
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
q.pop();
for (int i = h[x]; i != -1; i = ne[i]) {
int v = e[i];
if (num[v]) continue;
num[v] = y;
q.push({v, y});
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
int x, id = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
if (num[x]) continue;
q.push({x, ++id});
num[x] = id;
}
memset(h, -1, sizeof h);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u[i], &v[i]);
add(u[i], v[i]);
add(v[i], u[i]);
}
bfs();
int res = 0;
for (int i = 1; i <= n - 1; i++) {
if (num[u[i]] != num[v[i]]) res++;
}
printf("%d\n", res);
for (int i = 1; i <= n - 1; i++) {
if (num[u[i]] != num[v[i]]) printf("%d ", i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 0x3f3f3f3f3f3f3f3fll;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
T lcm(T a, T b) {
return b * a / __gcd(a, b);
}
int n, m, k, x;
const int MAX = 3e5 + 10;
int a[MAX];
set<int> ans;
vector<pair<int, int> > adj[MAX];
int vstd[MAX];
int main() {
int u, v;
deque<pair<int, int> > dq;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
scanf("%d", &x);
dq.push_back(make_pair(x, 0));
}
for (int i = 1; i <= n - 1; ++i) {
scanf("%d %d", &u, &v);
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
while (!dq.empty()) {
int f = dq.front().first;
int p = dq.front().second;
dq.pop_front();
if (vstd[f]) continue;
vstd[f] = 1;
for (auto o : adj[f]) {
if (o.first == p) continue;
if (vstd[o.first])
ans.insert(o.second);
else
dq.push_back({o.first, f});
}
}
printf("%d\n", ((int)(ans).size()));
for (int o : ans) printf("%d ", o);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
const long double pi = 3.14159265359;
const int INF = 1e9 + 7;
int n, k, ds, d[N], a, x[N], y[N], used[N];
vector<int> g[N], ans;
queue<int> q;
int main() {
cin >> n >> k >> ds;
for (int i = 1; i <= k; i++) {
cin >> a;
d[a] = i;
q.push(a);
used[a] = 1;
}
for (int i = 1; i < n; i++) {
cin >> x[i] >> y[i];
g[x[i]].push_back(y[i]);
g[y[i]].push_back(x[i]);
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto i : g[v]) {
if (!used[i]) {
d[i] = d[v];
used[i] = 1;
q.push(i);
}
}
}
for (int i = 1; i < n; i++) {
if (d[x[i]] != d[y[i]]) {
ans.push_back(i);
}
}
cout << ans.size() << '\n';
for (auto i : ans) {
cout << i << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, D;
vector<int> edge[310000];
int parent[310000];
map<pair<int, int>, int> mp;
int station[310000];
queue<int> q;
set<int> ans;
int32_t main() {
ios_base::sync_with_stdio(false);
if (fopen("cf796d.in", "r")) {
freopen("cf796d.in", "r", stdin);
freopen("cf796d.out", "w", stdout);
}
cin >> N >> K >> D;
for (int i = 0; i < K; i++) {
cin >> station[i];
station[i]--;
}
for (int i = 1; i < N; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
mp[make_pair(a, b)] = i;
mp[make_pair(b, a)] = i;
}
for (int i = 0; i < N; i++) {
parent[i] = -1;
}
for (int i = 0; i < K; i++) {
q.push(station[i]);
parent[station[i]] = -2;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (parent[v] == u || parent[u] == v) {
continue;
}
if (parent[v] != -1) {
ans.insert(mp[make_pair(u, v)]);
continue;
}
parent[v] = u;
q.push(v);
}
}
cout << ans.size() << '\n';
for (auto it = ans.begin(); it != ans.end(); it++) {
cout << *it << ' ';
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[300001], c[300001], kq;
int n, m, k, i, u, v, f[300001], dd[300001], d[300001], tr[300001];
queue<int> q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
memset(f, -1, sizeof(f));
for (i = 1; i <= m; i++) {
cin >> u;
dd[u] = 1;
f[u] = 0;
q.push(u);
tr[u] = u;
}
for (i = 1; i < n; i++) {
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
c[u].push_back(i);
c[v].push_back(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (f[v] == -1 && f[u] < k) {
tr[v] = tr[u];
f[v] = f[u] + 1;
q.push(v);
d[c[u][i]] = 1;
}
}
}
for (i = 1; i < n; i++)
if (d[i] == 0) kq.push_back(i);
cout << kq.size() << '\n';
for (i = 0; i < kq.size(); i++) cout << kq[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
struct Edge {
int to, nxt, id;
} edge[2 * N];
int head[N], tot;
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int id) {
edge[tot].id = id;
edge[tot].to = v;
edge[tot].nxt = head[u];
head[u] = tot++;
}
bool p[N];
int belong[N];
int ans[N], cnt, d;
void dfs(int u, int f) {
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
if (v == f) continue;
if (belong[v] != belong[u]) ans[cnt++] = edge[i].id;
dfs(v, u);
}
}
int main() {
init();
int n, k;
int u, v;
memset(p, false, sizeof(p));
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; i++) {
scanf("%d", &u);
p[u] = true;
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
addedge(u, v, i);
addedge(v, u, i);
}
memset(belong, -1, sizeof(belong));
queue<int> q;
for (int i = 1; i <= n; i++)
if (p[i]) q.push(i), belong[i] = i;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = edge[i].nxt) {
v = edge[i].to;
if (belong[v] != -1) continue;
belong[v] = belong[u];
q.push(v);
}
}
cnt = 0;
dfs(1, 1);
printf("%d\n", cnt);
for (int i = 0; i < cnt - 1; i++) printf("%d ", ans[i]);
if (cnt) printf("%d", ans[cnt - 1]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int from, to;
} E[600010 * 2];
int que[600010], dis[600010], ans, vis[600010 * 2];
int police[600010], edge_cnt, anss[600010];
int n, m, k, ne[600010 * 2], last[600010];
void add(int x, int y) {
E[++edge_cnt].from = x;
E[edge_cnt].to = y;
ne[edge_cnt] = last[x];
last[x] = edge_cnt;
}
void Insert() {
int x, y;
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
void bfs() {
int head = 1, tail = 0;
int u, v;
memset(dis, 0x7f, sizeof(dis));
for (int i = 1; i <= m; i++) {
que[++tail] = police[i];
dis[police[i]] = 0;
}
while (head <= tail) {
u = que[head];
for (int j = last[u]; j; j = ne[j]) {
int v = E[j].to;
if (vis[(j + 1) / 2]) continue;
if (dis[v] > dis[u] + 1 && dis[u] < k) {
vis[(j + 1) / 2] = 1;
dis[v] = dis[u] + 1;
que[++tail] = v;
}
if (dis[v] <= dis[u]) {
vis[(j + 1) / 2] = 1;
anss[++ans] = (j + 1) / 2;
}
}
head++;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) scanf("%d", &police[i]);
for (int i = 1; i <= n - 1; i++) Insert();
bfs();
cout << ans << endl;
for (int i = 1; i <= ans; i++) printf("%d ", anss[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3 * 100 * 1000 + 5;
vector<int> g[mxN];
int vis[mxN];
void solve() {
int n, k, d;
cin >> n >> k >> d;
queue<pair<int, int>> q;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
if (!vis[p]) {
vis[p] = 1;
q.push({p, d});
}
}
map<pair<int, int>, int> mp;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
mp[{min(u, v), max(u, v)}] = i;
g[u].push_back(v);
g[v].push_back(u);
}
set<int> ans;
vector<int> par(n);
while ((int)q.size()) {
int sz = q.size();
while (sz--) {
int cur, depth;
tie(cur, depth) = q.front();
q.pop();
depth--;
for (auto to : g[cur]) {
if (vis[to]) {
if (to != par[cur]) ans.insert(mp[{min(cur, to), max(cur, to)}]);
} else {
par[to] = cur;
vis[to] = 1;
if (depth >= 0) {
q.push({to, depth});
}
}
}
}
}
cout << (int)ans.size() << endl;
for (auto edge : ans) {
cout << edge << " ";
}
cout << endl;
}
int query = 0;
int main() {
int q = 1;
if (query) cin >> q;
while (q--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int vst[300005], vis[300005], dis[300005], a[300005];
vector<pair<int, int>> v[300005];
set<int> ans;
map<pair<int, int>, int> num;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
s;
void dfs(int node) {
vst[node] = 1;
for (auto ite : v[node])
if (!vst[ite.second]) {
if (dis[ite.second] == dis[node] + 1) {
dfs(ite.second);
} else {
ans.insert(num[{node, ite.second}]);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, d, i;
cin >> n >> k >> d;
for (i = 1; i <= k; ++i) cin >> a[i];
for (i = 1; i < n; ++i) {
int r, g;
cin >> r >> g;
num[{r, g}] = i;
num[{g, r}] = i;
v[r].push_back({1, g});
v[g].push_back({1, r});
}
for (i = 1; i <= n; ++i) dis[i] = d + 1;
for (i = 1; i <= k; ++i) {
dis[a[i]] = 0;
pair<int, int> p = {dis[a[i]], a[i]};
s.push(p);
}
while (!s.empty()) {
pair<int, int> e = s.top();
s.pop();
if (vis[e.second]) continue;
vis[e.second] = 1;
for (auto it : v[e.second]) {
if (dis[e.second] + it.first < dis[it.second]) {
dis[it.second] = dis[e.second] + it.first;
s.push({dis[it.second], it.second});
}
}
}
for (i = 1; i <= k; ++i)
if (!vst[a[i]]) dfs(a[i]);
cout << (int)(ans.size()) << "\n";
for (auto itr : ans) cout << itr << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(const T &x) {
return x * x;
}
inline long long sqr(int x) { return sqr<long long>(x); }
template <class T>
T binpow(const T &a, long long n) {
return n == 0 ? 1 : sqr(binpow(a, n / 2)) * (n % 2 ? a : 1);
}
long long binpow(long long a, long long n, long long modulo) {
return n == 0 ? 1
: sqr(binpow(a, n / 2, modulo)) % modulo * (n % 2 ? a : 1) %
modulo;
}
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
inline long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
if (n > 1) result -= result / n;
return result;
}
inline vector<long long> inverseAll(long long m) {
vector<long long> r(m);
r[1] = 1;
for (int i = 2; i < m; ++i) r[i] = (m - (m / i) * r[m % i] % m) % m;
return r;
}
inline long long gcd(long long a, long long b) { return gcd(a, b, a, b); }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long llrand() {
const long long lsbToFill = (sizeof(long long) << 3) - 1;
const long long bitsFilledInIteration = __builtin_popcountll(RAND_MAX);
long long number = 0;
for (long long lsbFilled = 0; lsbFilled <= lsbToFill;
lsbFilled += bitsFilledInIteration) {
number ^= (((long long)rand()) << lsbFilled);
}
return number & numeric_limits<long long>::max();
}
inline long long llrand(long long begin, long long end) {
return begin + llrand() % (end - begin);
}
struct Dinic {
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
int N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void AddEdge(int u, int v, long long cap) {
if (u != v) {
E.emplace_back(Edge(u, v, cap));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
vector<long long> Dijkstra(const vector<list<pair<int, long long>>> &g, int s) {
vector<long long> d(int((g).size()), numeric_limits<long long>::max() / 2LL);
priority_queue<pair<long long, int>> q;
d[s] = 0;
q.emplace(-0, s);
while (!q.empty()) {
while (q.top().first > d[q.top().second]) {
q.pop();
}
int v = q.top().second;
q.pop();
for (const auto &cw : g[v]) {
if (d[v] + cw.second < d[cw.first]) {
d[cw.first] = d[v] + cw.second;
q.emplace(-d[cw.first], cw.first);
}
}
}
return d;
}
struct BinarySearchIterator
: public std::iterator<std::forward_iterator_tag, bool> {
long long value;
typename iterator_traits<BinarySearchIterator>::difference_type operator-(
const BinarySearchIterator &it) const {
return value - it.value;
}
BinarySearchIterator &operator++() {
++value;
return *this;
}
bool operator!=(const BinarySearchIterator &it) const {
return value != it.value;
}
bool operator*() const { return true; }
};
template <int ALPHA>
class AhoCorasick {
public:
static const int ILLEGAL_INDEX;
static const int ROOT;
struct Node {
bool leaf;
int parent;
int parentCharacter;
int link;
int next[ALPHA];
int go[ALPHA];
int outputFunction;
Node(int parent = ILLEGAL_INDEX, int parentCharacter = ALPHA)
: leaf(false),
parent(parent),
parentCharacter(parentCharacter),
link(ILLEGAL_INDEX),
outputFunction(ILLEGAL_INDEX) {
fill_n(next, ALPHA, ILLEGAL_INDEX);
fill_n(go, ALPHA, ILLEGAL_INDEX);
}
};
vector<Node> tree = vector<Node>(1);
AhoCorasick() {}
AhoCorasick(int maxStatesNumber) { tree.reserve(maxStatesNumber); }
template <class Iterator>
void add(int length, const Iterator begin) {
int vertex = ROOT;
for (int i = 0; i < length; ++i) {
if (ILLEGAL_INDEX == tree[vertex].next[begin[i]]) {
tree[vertex].next[begin[i]] = int((tree).size());
tree.push_back(Node(vertex, begin[i]));
}
vertex = tree[vertex].next[begin[i]];
}
tree[vertex].leaf = true;
}
int getLink(int vertex) {
assert(0 <= vertex && vertex < tree.size());
if (ILLEGAL_INDEX == tree[vertex].link) {
if (ROOT == vertex || ROOT == tree[vertex].parent) {
tree[vertex].link = ROOT;
} else {
tree[vertex].link =
go(getLink(tree[vertex].parent), tree[vertex].parentCharacter);
}
}
return tree[vertex].link;
}
int go(int vertex, int character) {
assert(0 <= character && character < ALPHA);
assert(0 <= vertex && vertex < tree.size());
if (ILLEGAL_INDEX == tree[vertex].go[character]) {
if (ILLEGAL_INDEX == tree[vertex].next[character]) {
tree[vertex].go[character] =
ROOT == vertex ? ROOT : go(getLink(vertex), character);
} else {
tree[vertex].go[character] = tree[vertex].next[character];
}
}
return tree[vertex].go[character];
}
int getOutputFunction(int vertex) {
assert(0 <= vertex && vertex < tree.size());
if (ILLEGAL_INDEX == tree[vertex].outputFunction) {
if (tree[vertex].leaf || ROOT == vertex) {
tree[vertex].outputFunction = vertex;
} else {
tree[vertex].outputFunction = getOutputFunction(getLink(vertex));
}
}
return tree[vertex].outputFunction;
}
};
template <int ALPHA>
const int AhoCorasick<ALPHA>::ILLEGAL_INDEX = -1;
template <int ALPHA>
const int AhoCorasick<ALPHA>::ROOT = 0;
struct UnionFind {
vector<int> parent;
vector<int> rank;
UnionFind(int n) : parent(n), rank(n) {
for (int i = 0; i < n; ++i) {
parent[i] = i;
rank[i] = 0;
}
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rank[a] < rank[b]) swap(a, b);
parent[b] = a;
if (rank[a] == rank[b]) ++rank[a];
}
}
};
template <class T>
T assign(const T &a, const T &b) {
return b;
}
template <class T>
struct SegmentTree {
int n;
vector<T> t;
function<T(const T &, const T &)> operation;
T default_value;
function<T(const T &, const T &)> modification;
SegmentTree() {}
SegmentTree(const int n, const function<T(T, T)> &operation,
const T &default_value = T(),
const function<T(T, T)> &modification = assign<T>)
: SegmentTree(vector<T>(n, default_value), operation, default_value,
modification) {}
SegmentTree(const vector<T> &a, const function<T(T, T)> &operation,
const T &default_value = T(),
const function<T(T, T)> &modification = assign<T>)
: n((int)a.size()),
t(n << 1),
operation(operation),
default_value(default_value),
modification(modification) {
copy(a.begin(), a.end(), t.begin() + n);
for (int i = n - 1; i > 0; --i) t[i] = operation(t[i << 1], t[i << 1 | 1]);
}
void modify(int p, T value) {
p += n;
for (t[p] = modification(t[p], value); p > 1; p >>= 1)
t[p >> 1] = operation(t[p], t[p ^ 1]);
}
T query(int l, int r) const {
T res = default_value;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = operation(res, t[l++]);
if (r & 1) res = operation(res, t[--r]);
}
return res;
}
};
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(13);
cout.setf(ios::fixed);
srand((unsigned int)time(NULL));
int n, k, d;
while (cin >> n >> k >> d) {
vector<int> p(k);
for (int i = 0; i < k; ++i) {
cin >> p[i];
--p[i];
}
vector<list<int>> g(n);
map<pair<int, int>, int> edge2index;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back((v));
g[v].push_back((u));
edge2index[{min(u, v), max(u, v)}] = i;
}
list<int> q;
vector<int> used(n, false);
for (int v : p) {
q.emplace_back(v);
used[v] = true;
}
while (int((q).size())) {
int v = q.front();
q.pop_front();
for (int c : g[v]) {
if (!used[c]) {
q.emplace_back(c);
used[c] = true;
edge2index.erase({min(v, c), max(v, c)});
}
}
}
cout << int((edge2index).size()) << endl;
for (const auto &edge_index : edge2index) {
cout << edge_index.second << ' ';
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int has[300005];
vector<pair<int, int> > adj[300005];
int shut[300005];
bool vis[300005];
int dis[300005];
int p[300005];
int main() {
int n, k, d;
scanf("%d %d %d", &n, &k, &d);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
has[x] = 1;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(pair<int, int>(v, i + 1));
adj[v].push_back(pair<int, int>(u, i + 1));
dis[i + 1] = 1e9;
}
queue<int> Q;
for (int i = 1; i <= n; i++)
if (has[i]) {
vis[i] = 1;
dis[i] = 0;
Q.push(i);
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (dis[u] > d) break;
for (auto x : adj[u]) {
int v = x.first, id = x.second;
if (v == p[u]) continue;
if (!vis[v]) {
vis[v] = 1;
p[v] = u;
dis[v] = dis[u] + 1;
Q.push(v);
} else {
shut[id] = 1;
}
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (shut[i]) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (shut[i]) printf("%d\n", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 3e6 + 7;
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
int n, k, d;
int i, j, t;
int a[maxn];
vector<int> edge[maxn];
int from[maxn];
bool ans[maxn], mark[maxn];
int num;
queue<int> Q;
int u, v;
int XOR[maxn];
int main() {
scanf("%d%d%d", &n, &k, &d);
for (i = 1; i <= k; i++) {
scanf("%d", &j);
if (!mark[j]) Q.push(j);
mark[j] = 1;
}
for (i = 1; i <= n; i++) ans[i] = 0;
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(i);
edge[v].push_back(i);
XOR[i] = u ^ v;
}
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (i = 0; i < edge[u].size(); i++) {
t = edge[u][i];
v = XOR[t] ^ u;
if (from[u] == v) continue;
if (mark[v])
ans[t] = 1;
else {
from[v] = u;
mark[v] = 1;
Q.push(v);
}
}
}
for (i = 1; i <= n; i++) num += ans[i];
printf("%d\n", num);
for (i = 1; i <= n; i++)
if (ans[i]) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
int di[300055];
int par[300055];
bool have[300055];
set<pair<int, int> > g[300055];
queue<int> que;
int main() {
scanf("%d %d %d", &n, &k, &d);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
x--;
have[x] = true;
}
for (int i = 0; i + 1 < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
g[x].insert(pair<int, int>(y, i));
g[y].insert(pair<int, int>(x, i));
}
memset(par, -1, sizeof(par));
memset(di, -1, sizeof(di));
for (int i = 0; i < n; i++)
if (have[i]) {
que.push(i);
di[i] = 0;
}
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto p : g[u]) {
if (di[p.first] < 0) {
di[p.first] = di[u] + 1;
par[p.first] = u;
que.push(p.first);
}
}
}
set<int> res;
for (int i = 0; i < n; i++)
for (auto p : g[i]) {
if (par[i] == p.first || par[p.first] == i) continue;
res.insert(p.second);
}
printf("%d\n", (int)res.size());
bool flag = false;
for (auto u : res) {
if (flag)
printf(" ");
else
flag = true;
printf("%d", u + 1);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int u[300005], v[300005];
vector<int> g[300005];
int p[300005], vis[300005];
vector<int> vec[2];
vector<int> V[2][300005];
int main() {
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= k; ++i) {
int x;
scanf("%d", &x);
p[x] = 1;
}
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d", u + i, v + i);
g[u[i]].push_back(v[i]);
g[v[i]].push_back(u[i]);
}
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (p[i]) {
vis[i] = ++cnt;
vec[0].push_back(cnt);
V[0][cnt].push_back(i);
}
int now = 0;
for (int i = 1; i <= d; ++i) {
int nex = now ^ 1;
vec[nex].clear();
for (int j = 0; j < (int)vec[now].size(); ++j) {
int curid = vec[now][j];
V[nex][curid].clear();
for (int _ = 0; _ < (int)V[now][curid].size(); ++_) {
int x = V[now][curid][_];
for (int k = 0; k < (int)g[x].size(); ++k) {
int y = g[x][k];
if (!vis[y]) {
vis[y] = curid;
V[nex][curid].push_back(y);
}
}
}
if (V[nex][curid].size()) vec[nex].push_back(curid);
}
now = nex;
}
vector<int> ans;
for (int i = 1; i <= n - 1; ++i)
if (vis[u[i]] != vis[v[i]]) ans.push_back(i);
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); ++i) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int D[300001];
int P[300001];
bool S[300001];
vector<pair<int, int>> G[300001];
void solve() {
int n, k, d, x, u, v;
cin >> n >> k >> d;
for (int i = 0; i < k; ++i) {
cin >> x;
S[x] = true;
}
for (int i = 1; i < n; ++i) {
cin >> u >> v;
G[u].push_back({v, i});
G[v].push_back({u, i});
}
queue<int> Q;
fill(D, D + n + 1, -1);
fill(P, P + n + 1, -1);
for (int i = 1; i <= n; ++i)
if (S[i]) {
D[i] = 0;
Q.push(i);
}
vector<int> ans;
while (!Q.empty()) {
int k = Q.front();
Q.pop();
for (auto const& u : G[k]) {
if (P[k] == u.first) continue;
if (D[u.first] != -1) {
if (k < u.first) ans.push_back(u.second);
} else {
D[u.first] = D[k] + 1;
P[u.first] = k;
Q.push(u.first);
}
}
}
cout << ans.size() << '\n';
for (int k : ans) cout << k << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
vector<int> station = vector<int>(n, 0);
for (size_t i = 0; i < k; i++) {
int st;
scanf("%d", &st);
st--;
station[st] = 1;
}
vector<vector<pair<int, int> > > AdjList =
vector<vector<pair<int, int> > >(n, vector<pair<int, int> >());
for (size_t i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
AdjList[u].push_back(pair<int, int>(v, i));
AdjList[v].push_back(pair<int, int>(u, i));
}
vector<int> dist = vector<int>(n, -1);
vector<int> distEdge = vector<int>(n - 1, 0);
queue<pair<int, int> > q = queue<pair<int, int> >();
for (size_t i = 0; i < n; i++) {
if (station[i]) {
q.push(pair<int, int>(0, i));
dist[i] = 0;
}
}
int ans = 0;
vector<int> ans_ = vector<int>();
while (!q.empty()) {
pair<int, int> top = q.front();
q.pop();
int d = top.first;
int u = top.second;
for (size_t i = 0; i < AdjList[u].size(); i++) {
pair<int, int> v = AdjList[u][i];
if (distEdge[v.second]) continue;
distEdge[v.second] = 1;
if (dist[v.first] == -1) {
dist[v.first] = d + 1;
q.push(pair<int, int>(d + 1, v.first));
} else {
ans++;
ans_.push_back(v.second);
}
}
}
printf("%d\n", ans);
for (int i = 0; i < ans_.size(); i++) {
printf("%d", ans_[i] + 1);
if (i == ans_.size() - 1) {
printf("\n");
} else
printf(" ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int n, k, d;
vector<pair<int, int> > G[N];
bool mk[N], frozen[N];
int from[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> d;
queue<int> q;
memset(from, -1, sizeof from);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
q.push(x);
from[x] = x;
mk[x] = true;
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
G[u].push_back({v, i});
G[v].push_back({u, i});
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto pp : G[u]) {
int v = pp.first;
if (!mk[v]) {
mk[v] = true;
from[v] = from[u];
q.push(v);
}
}
}
for (int i = 1; i <= n; i++) {
for (auto pp : G[i]) {
int v = pp.first;
int idx = pp.second;
if (from[i] != from[v]) {
frozen[idx] = true;
}
}
}
int res = count(frozen + 1, frozen + 1 + n - 1, true);
cout << res << '\n';
for (int i = 1; i <= n - 1; i++) {
if (frozen[i]) cout << i << " ";
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
map<pair<int, int>, int> check;
vector<int> adj[300001];
int dis[300001];
set<int> uniquee;
int parr[300001] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> d;
queue<pair<int, int> > qu;
int j;
for (j = 1; j <= n; j++) {
dis[j] = -1;
}
for (j = 0; j < k; j++) {
int a;
cin >> a;
if (dis[a] == -1) {
dis[a] = 0;
qu.push(make_pair(a, 0));
}
}
int a, b;
for (j = 0; j < n - 1; j++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
check[make_pair(a, b)] = j + 1;
check[make_pair(b, a)] = j + 1;
}
while (!qu.empty()) {
int node = qu.front().first;
int dist = qu.front().second;
qu.pop();
int j;
for (j = 0; j < adj[node].size(); j++) {
if (dis[adj[node][j]] == -1) {
parr[adj[node][j]] = node;
dis[adj[node][j]] = dist + 1;
qu.push(make_pair(adj[node][j], dist + 1));
} else if (parr[node] != adj[node][j]) {
int aa = check[make_pair(node, adj[node][j])];
uniquee.insert(aa);
}
}
}
cout << uniquee.size() << "\n";
set<int>::iterator it;
for (it = uniquee.begin(); it != uniquee.end(); it++) {
cout << *it << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
struct Edge {
int to, id;
};
int N, K, D;
queue<int> Q;
vector<Edge> G[MAXN];
bool vis[MAXN], used[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K >> D;
for (int i = 0; i < K; i++) {
int x;
cin >> x;
Q.push(x);
vis[x] = true;
}
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v;
G[u].push_back({v, i + 1});
G[v].push_back({u, i + 1});
}
while (!Q.empty()) {
int v = Q.front();
Q.pop();
for (Edge &e : G[v]) {
if (!vis[e.to]) {
vis[e.to] = true;
used[e.id] = true;
Q.push(e.to);
}
}
}
vector<int> ans;
for (int i = 1; i <= N - 1; i++) {
if (!used[i]) {
ans.push_back(i);
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << (i + 1 < ans.size() ? ' ' : '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6 + 42 + 17;
int n, a[MAXN], pc, d, par[MAXN];
vector<int> adj[MAXN];
vector<pair<int, int> > P;
int dist[MAXN];
pair<int, int> e[MAXN];
void mainp() {
cin >> n >> pc >> d;
for (int i = 0; i < pc; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[v].push_back(u);
adj[u].push_back(v);
e[i + 1] = {u, v};
}
memset(dist, -1, sizeof(dist));
queue<int> q;
for (int i = 0; i < pc; i++) {
q.push(a[i]);
par[a[i]] = -1;
dist[a[i]] = 0;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
par[v] = u;
q.push(v);
}
}
}
map<pair<int, int>, bool> has;
for (int i = 1; i <= n; i++)
if (par[i] != -1) {
has[{i, par[i]}] = 1;
has[{par[i], i}] = 1;
}
vector<int> ans;
for (int i = 1; i < n; i++)
if (!has.count(e[i])) ans.push_back(i);
cout << ans.size() << '\n';
for (int x : ans) cout << x << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
mainp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 5005, M = 0, Z = 1e9 + 7;
const int inf = 0x3f3f3f3f;
template <class T1, class T2>
inline void gadd(T1 &a, T2 b) {
a = (a + b) % Z;
}
int casenum, casei;
int n, m;
int f[N][N];
int d[N][N];
int v[N];
int c[N];
vector<int> a[N];
int sz[N];
void dfs(int x) {
f[x][0] = d[x][0] = sz[x] = 0;
for (auto y : a[x]) {
dfs(y);
for (int i = sz[x]; ~i; --i) {
for (int j = 1; j <= sz[y]; ++j) {
gmin(f[x][i + j], f[x][i] + f[y][j]);
gmin(f[x][i + j], f[x][i] + d[y][j]);
gmin(d[x][i + j], d[x][i] + d[y][j]);
}
}
sz[x] += sz[y];
}
++sz[x];
for (int i = sz[x]; i; --i) {
f[x][i] = min(f[x][i - 1] + v[x] - c[x], inf);
gmin(d[x][i], d[x][i - 1] + v[x]);
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(f, 63, sizeof(f));
memset(d, 63, sizeof(d));
for (int i = 1; i <= n; ++i) {
a[i].clear();
scanf("%d%d", &v[i], &c[i]);
if (i > 1) {
int fa;
scanf("%d", &fa);
a[fa].push_back(i);
}
}
dfs(1);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (f[1][i] <= m || d[1][i] <= m) {
gmax(ans, i);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
int b, sz[5001], c[5001], d[5001], f[5001][5001][2];
vector<int> son[5001];
void dp(int x) {
sz[x] = 1;
f[x][1][0] = c[x];
f[x][1][1] = c[x] - d[x];
for (int i = 0; i < son[x].size(); i++) {
int now = son[x][i];
dp(now);
for (int j = sz[x]; j >= 0; j--)
for (int k = sz[now]; k; k--) {
f[x][j + k][0] = min(f[x][j + k][0], f[x][j][0] + f[now][k][0]);
if (j)
f[x][j + k][1] =
min(f[x][j + k][1], f[x][j][1] + min(f[now][k][0], f[now][k][1]));
}
sz[x] += sz[now];
}
}
int main() {
int n;
scanf("%d%d", &n, &b);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &d[i]);
if (i > 1) {
int x;
scanf("%d", &x);
son[x].push_back(i);
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j][0] = f[i][j][1] = 1000000001;
dp(1);
for (int i = n; i >= 0; i--)
if (min(f[1][i][0], f[1][i][1]) <= b) {
printf("%d", i);
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
const int inf = 1e9 + 1;
const int mod = 1e9 + 7;
const double eps = 1e-15;
const int pw = 257;
int n, b, f[N][N], g[N][N], c[N], d[N], s[N];
vector<int> t[N];
void dfs(int v) {
++s[v];
for (int i = 0; i < int(t[v].size()); ++i) {
int to = t[v][i];
dfs(to);
for (int j = 0; j <= s[v]; ++j) {
c[j] = f[v][j];
d[j] = g[v][j];
}
for (int j = 0; j <= s[v]; ++j) {
for (int k = 0; k <= s[to]; ++k) {
g[v][j + k] = min(g[v][j + k], d[j] + g[to][k]);
if (j >= 1) f[v][j + k] = min(f[v][j + k], c[j] + f[to][k]);
}
}
s[v] += s[to];
}
for (int j = 0; j <= s[v]; ++j) f[v][j] = min(f[v][j], g[v][j]);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> b;
for (int i = 1; i <= n; ++i) {
for (int j = 2; j <= n; ++j) f[i][j] = g[i][j] = inf;
int c, d;
cin >> c >> d;
f[i][1] = c - d;
g[i][1] = c;
if (i != 1) {
int x;
cin >> x;
t[x].push_back(i);
}
}
dfs(1);
int ans;
for (int j = 0; j <= n; ++j)
if (f[1][j] <= b) ans = j;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 5000 + 5;
int n, m;
int pa[maxn], pb[maxn];
int sz[maxn];
int d[maxn][maxn][2];
vector<int> g[maxn];
void dfs(int u) {
sz[u] = 1;
d[u][0][0] = 0, d[u][1][0] = pa[u], d[u][1][1] = pa[u] - pb[u];
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
dfs(v);
for (int j = sz[u]; j >= 0; j--) {
for (int k = 0; k <= sz[v]; k++) {
d[u][j + k][0] = min(d[u][j + k][0], d[u][j][0] + d[v][k][0]);
d[u][j + k][1] = min(d[u][j + k][1], min(d[u][j][1] + d[v][k][1],
d[u][j][1] + d[v][k][0]));
}
}
sz[u] += sz[v];
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i <= n; i++) {
scanf("%d%d", &pa[i], &pb[i]);
if (i > 1) {
int x;
scanf("%d", &x);
g[x].push_back(i);
}
}
memset(d, INF, sizeof(d));
dfs(1);
int i;
for (i = 0; i <= n; i++) {
if (min(d[1][i][0], d[1][i][1]) > m) break;
}
printf("%d\n", i - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int h[5005], ne[5005], to[5005], en = 0;
unsigned int dp[5005][5005][2], tmp[5005][2];
int n, b, c[5005], d[5005], siz[5005];
void add(int a, int b) {
to[en] = b;
ne[en] = h[a];
h[a] = en++;
}
void Tree_DP(int o) {
for (int i = 0; i <= n; ++i) dp[o][i][0] = dp[o][i][1] = 2100000000;
dp[o][1][1] = c[o] - d[o];
dp[o][1][0] = c[o];
dp[o][0][0] = 0;
siz[o] = 1;
for (int i = h[o]; i >= 0; i = ne[i]) {
Tree_DP(to[i]);
for (int j = 0; j <= siz[o] + siz[to[i]]; ++j)
tmp[j][0] = tmp[j][1] = 2100000000;
for (int j = 0; j <= siz[o]; ++j)
for (int k = 0; k <= siz[to[i]]; ++k) {
if (dp[o][j][0] < 2100000000 && dp[to[i]][k][0] < 2100000000)
tmp[j + k][0] =
min((long long)tmp[j + k][0],
(long long)dp[o][j][0] + (long long)dp[to[i]][k][0]);
if (dp[o][j][1] < 2100000000 && dp[to[i]][k][1] < 2100000000)
tmp[j + k][1] = min((long long)tmp[j + k][1],
(long long)dp[o][j][1] + dp[to[i]][k][1]);
if (dp[o][j][1] < 2100000000 && dp[to[i]][k][0] < 2100000000)
tmp[j + k][1] = min((long long)tmp[j + k][1],
(long long)dp[o][j][1] + dp[to[i]][k][0]);
}
for (int j = 0; j <= siz[o] + siz[to[i]]; ++j) {
dp[o][j][0] = tmp[j][0];
dp[o][j][1] = tmp[j][1];
}
siz[o] += siz[to[i]];
}
return;
}
int main() {
memset(h, -1, sizeof h);
scanf("%d%d", &n, &b);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &c[i], &d[i]);
int x;
if (i != 1) {
scanf("%d", &x);
add(x, i);
}
}
Tree_DP(1);
int ans = 0;
for (int i = n; i >= 0; --i)
if (min(dp[1][i][0], dp[1][i][1]) <= (unsigned int)b) ans = max(ans, i);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, b, c[5002], d[5002], sub[5005];
vector<int> v[5005];
vector<long long> g[5005];
long long f[5005][5005];
multimap<int, int>* havec[5005];
void merge(multimap<int, int>& sm, multimap<int, int>& big) {
auto it = sm.begin();
while (it != sm.end()) {
big.insert(multimap<int, int>::value_type(it->first, 1));
++it;
}
}
void prego(int now) {
(*havec[now]).insert(multimap<int, int>::value_type(c[now], 1));
f[now][0] = 0;
for (int i = 0; i < v[now].size(); i++) {
int next = v[now][i];
prego(next);
if ((int)(*havec[now]).size() < (int)(*havec[next]).size()) {
merge(*havec[now], *havec[next]);
havec[now] = havec[next];
} else {
merge(*havec[next], *havec[now]);
havec[next] = havec[now];
}
for (int j = sub[now]; j >= 0; j--) {
for (int k = 1; k <= sub[next]; k++) {
f[now][j + k] = min(f[now][j + k], f[now][j] + f[next][k]);
}
}
sub[now] += sub[next];
}
sub[now]++;
for (int i = sub[now]; i >= 1; i--) {
f[now][i] = f[now][i - 1] + (long long)(c[now] - d[now]);
}
g[now].resize(sub[now] + 1);
auto it = (*havec[now]).begin();
for (int j = 1; j <= sub[now]; j++) {
g[now][j] = g[now][j - 1] + (long long)it->first;
f[now][j] = min(f[now][j], g[now][j]);
++it;
}
}
int main() {
scanf("%d %d", &n, &b);
for (int i = 1; i <= n; i++) {
havec[i] = new multimap<int, int>();
for (int j = 0; j <= n; j++) {
f[i][j] = 1e15;
}
}
scanf("%d %d", &c[1], &d[1]);
for (int par, i = 2; i <= n; i++) {
scanf("%d %d %d", &c[i], &d[i], &par);
v[par].push_back(i);
}
prego(1);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (f[1][i] <= b) {
ans = i;
} else
break;
}
printf("%d\n", ans);
free(havec[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 5050;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x;
}
int n, money, num_edge;
int num[SIZE], low[SIZE], son[SIZE], head[SIZE], siz[SIZE];
int dp[SIZE][SIZE][2];
struct node {
int to, nxt;
};
node edge[SIZE];
inline void add(int u, int v) {
edge[++num_edge].to = v;
edge[num_edge].nxt = head[u];
head[u] = num_edge;
}
void dfs(int u) {
siz[u] = 1;
dp[u][0][0] = 0;
dp[u][1][0] = num[u];
dp[u][1][1] = num[u] - low[u];
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
dfs(v);
for (int j = siz[u]; j >= 0; --j) {
for (int k = 0; k <= siz[v]; ++k) {
dp[u][j + k][0] = min(dp[u][j + k][0], dp[u][j][0] + dp[v][k][0]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][1]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][0]);
}
}
siz[u] += siz[v];
}
}
int main() {
n = read();
money = read();
num[1] = read();
low[1] = read();
for (int i = 2; i <= n; ++i) {
num[i] = read();
low[i] = read();
son[i] = read();
add(son[i], i);
}
memset(dp, 0x3f, sizeof(dp));
dp[1][1][1] = num[1] - low[1];
dfs(1);
for (int i = n; i >= 1; --i) {
if (dp[1][i][1] <= money || dp[1][i][0] <= money) {
printf("%d\n", i);
return 0;
}
}
printf("0\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
vector<long long> dp[2][maxn];
vector<int> vect[maxn];
long long c[maxn], d[maxn], b, inf = 1e18;
int sz[maxn], n;
void go_sz(int x) {
sz[x] = 1;
for (int i = 0; i < vect[x].size(); i++) {
int id = vect[x][i];
go_sz(id);
sz[x] += sz[id];
}
}
void go(int x) {
dp[1][x].resize(sz[x] + 1);
dp[0][x].resize(sz[x] + 1);
fill(dp[1][x].begin(), dp[1][x].end(), inf);
fill(dp[0][x].begin(), dp[0][x].end(), inf);
dp[0][x][0] = 0;
dp[0][x][1] = c[x];
dp[1][x][0] = 0;
dp[1][x][1] = c[x] - d[x];
int pom = 1;
for (int i = 0; i < vect[x].size(); i++) {
int id = vect[x][i];
go(id);
for (int j = pom; j >= 1; j--) {
for (int k = sz[id]; k >= 1; k--) {
if (dp[1][x][j] == inf) continue;
dp[1][x][j + k] = min(dp[1][x][j + k], dp[1][x][j] + dp[0][id][k]);
dp[1][x][j + k] = min(dp[1][x][j + k], dp[1][x][j] + dp[1][id][k]);
}
}
for (int j = pom; j >= 0; j--) {
for (int k = sz[id]; k >= 1; k--) {
if (dp[0][x][j] == inf) continue;
dp[0][x][j + k] = min(dp[0][x][j + k], dp[0][x][j] + dp[0][id][k]);
}
}
pom += sz[id];
}
}
int main() {
scanf("%d %lld", &n, &b);
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", &c[i], &d[i]);
if (i > 1) {
int u;
scanf("%d", &u);
vect[u].push_back(i);
}
}
go_sz(1);
go(1);
for (int i = n; i >= 0; i--) {
if (dp[0][1][i] <= b || dp[1][1][i] <= b) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return;
}
int get() {
char c;
int v;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return v;
}
struct node {
int v;
node *next;
} * adj[5000 + 4], edge[5000 + 4], *CNT = edge;
struct xjb {
int c, d, v;
node *s;
} goods[5000 + 4];
int f[5000 + 4][5000 + 4], g[5000 + 4][5000 + 4];
int subtreesz[5000 + 4];
void addedge(int u, int v) {
node *p = ++CNT;
p->v = v;
p->next = goods[u].s;
goods[u].s = p;
return;
}
void dfs(int s) {
node *p;
int i, j;
f[s][1] = goods[s].c - goods[s].d;
g[s][0] = 0;
g[s][1] = goods[s].c;
subtreesz[s] = 1;
for (p = goods[s].s; p; p = p->next) {
dfs(p->v);
for (i = subtreesz[s]; ~i; i--)
for (j = subtreesz[p->v]; j; j--) {
f[s][i + j] = min(f[s][i + j], f[s][i] + min(f[p->v][j], g[p->v][j]));
g[s][i + j] = min(g[s][i + j], g[s][i] + g[p->v][j]);
}
subtreesz[s] += subtreesz[p->v];
}
return;
}
int main() {
int n, i, Lim;
get(n);
get(Lim);
for (i = 1; i <= n; i++) {
get(goods[i].c);
get(goods[i].d);
if (i > 1) addedge(get(), i);
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
dfs(1);
for (i = 0; i < n && (min(f[1][i + 1], g[1][i + 1]) <= Lim); i++)
;
printf("%d", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
int n, b, x, ans, f[5005][5005], g[5005][5005];
vi c, d, sz;
vvi adj;
void init() {
adj.resize(n + 1);
c.resize(n + 1);
d.resize(n + 1);
sz.assign(n + 1, 0);
memset(f, 0x3f3f3f3f, sizeof f);
memset(g, 0x3f3f3f3f, sizeof g);
}
void dfs(int u) {
f[u][1] = c[u] - d[u];
g[u][1] = c[u];
g[u][0] = 0;
sz[u]++;
int curr = 1;
for (auto v : adj[u]) dfs(v), sz[u] += sz[v];
for (auto v : adj[u]) {
for (int i = curr; i >= 0; i--)
for (int j = sz[v]; j >= 1; j--) {
f[u][i + j] = min(f[u][i + j], f[u][i] + min(f[v][j], g[v][j]));
g[u][i + j] = min(g[u][i + j], g[u][i] + g[v][j]);
}
curr += sz[v];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> b;
init();
cin >> c[1] >> d[1];
for (int i = 2; i <= n; i++) {
cin >> c[i] >> d[i] >> x;
adj[x].push_back(i);
}
dfs(1);
for (int i = 1; i <= n; i++)
if (min(f[1][i], g[1][i]) <= b) ans = max(ans, i);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ReadInt() {
int o = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) o = o * 10 + ch - '0', ch = getchar();
return o;
}
int n, b, q, c[5000 + 10], d[5000 + 10], sz[5000 + 10],
dp[5000 + 10][5000 + 10][2];
vector<int> g[5000 + 10];
void dfs(int u) {
dp[u][0][0] = 0;
dp[u][1][0] = c[u];
dp[u][1][1] = c[u] - d[u];
sz[u] = 1;
for (auto v : g[u]) {
dfs(v);
for (int i = sz[u]; i >= 0; i--) {
for (int j = sz[v]; j >= 0; j--) {
dp[u][i + j][0] = min(dp[u][i + j][0], dp[u][i][0] + dp[v][j][0]);
dp[u][i + j][1] =
min(dp[u][i + j][1], dp[u][i][1] + min(dp[v][j][0], dp[v][j][1]));
}
}
sz[u] += sz[v];
}
}
int main() {
while (~scanf("%d%d", &n, &b)) {
for (int i = 0; i <= n; i++) g[i].clear();
memset(dp, 60, sizeof(dp));
for (int i = 1, x; i <= n; i++) {
c[i] = ReadInt();
d[i] = ReadInt();
if (i >= 2) {
x = ReadInt();
g[x].push_back(i);
}
}
dfs(1);
int ans;
for (int i = 0; i <= n; i++)
if (min(dp[1][i][1], dp[1][i][0]) <= b) ans = i;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, b;
int c[5005], d[5005];
int f[5005][5005];
int g[5005][5005];
int sz[5005], fat[5005];
vector<int> vec[5005];
void init() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = g[i][j] = 1000000002;
}
void dfs(int v, int w) {
sz[v]++;
int mas = -1, num = -1;
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i];
if (to == w) continue;
dfs(to, v);
sz[v] += sz[to];
if (sz[to] > mas) {
mas = sz[to];
num = to;
}
}
fat[v] = num;
}
void solve(int v, int w) {
int *f2;
int *g2;
int SZ = sz[v] + 5;
f2 = new int[SZ];
g2 = new int[SZ];
f2[0] = g2[0] = 0;
for (int i = 1; i < SZ; i++) f2[i] = g2[i] = 1000000002;
f[v][1] = f2[1] = c[v] - d[v];
g[v][1] = g2[1] = c[v];
int sum = 1;
for (int q = 0; q < vec[v].size(); q++) {
int to = vec[v][q];
if (to == w) continue;
solve(to, v);
if (to == fat[v]) continue;
for (int i = 1; i <= sum + sz[to]; i++) {
for (int j = max(0, i - sum); j <= min(sz[to], i - 1); j++)
f2[i] = min(f2[i], f[v][i - j] + f[to][j]);
for (int j = max(0, i - sum); j <= min(sz[to], i); j++)
g2[i] = min(g2[i], g[v][i - j] + g[to][j]);
}
sum += sz[to];
for (int i = 1; i <= sum; i++) {
f[v][i] = min(f[v][i], f2[i]);
g[v][i] = min(g[v][i], g2[i]);
f2[i] = 1000000002;
g2[i] = 1000000002;
}
}
if (fat[v] == -1) return;
int to = fat[v];
if (sz[to] > sz[v] - sz[to]) {
for (int i = 1; i <= sz[v]; i++) {
for (int j = 1; j <= min(sz[v] - sz[to], i); j++)
f2[i] = min(f2[i], f[v][j] + f[to][i - j]);
for (int j = 0; j <= min(sz[v] - sz[to], i); j++)
g2[i] = min(g2[i], g[v][j] + g[to][i - j]);
}
} else {
for (int i = 1; i <= sz[v]; i++) {
for (int j = 0; j <= min(sz[to], i - 1); j++)
f2[i] = min(f2[i], f[v][i - j] + f[to][j]);
for (int j = 0; j <= min(sz[to], i); j++)
g2[i] = min(g2[i], g[v][i - j] + g[to][j]);
}
}
for (int i = 1; i <= sz[v]; i++) {
f[v][i] = min(f[v][i], f2[i]);
g[v][i] = min(g[v][i], g2[i]);
f[v][i] = min(f[v][i], g[v][i]);
}
delete[] f2;
delete[] g2;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> b;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> d[i];
if (i > 1) {
int u;
cin >> u;
vec[i].push_back(u);
vec[u].push_back(i);
}
}
init();
dfs(1, 0);
solve(1, 0);
while (f[1][n] > b) n--;
cout << n << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int MAXN = 5100;
int c[MAXN], d[MAXN], sz[MAXN];
long long int dp[MAXN][MAXN];
vector<int> v[MAXN];
bool cmp(int a, int b) { return v[a].size() < v[b].size(); }
void cSize(int node) {
sz[node] = 1;
for (int to : v[node]) {
cSize(to);
sz[node] += sz[to];
}
sort(v[node].begin(), v[node].end(), cmp);
}
void dfs(int node, vector<int> &a) {
dp[node][1] = c[node] - d[node];
dp[node][0] = 0;
vector<int> ma;
int s = 1;
for (int to : v[node]) {
dfs(to, ma);
for (int i = s; i >= 1; i--)
for (int j = 1; j <= sz[to]; j++)
dp[node][i + j] = min(dp[node][i + j], dp[node][i] + dp[to][j]);
s += sz[to];
}
ma.push_back(c[node]);
a.insert(a.end(), ma.begin(), ma.end());
sort(ma.begin(), ma.end());
long long int sum = 0;
for (int i = 1; i <= ma.size(); i++) {
sum += ma[i - 1];
dp[node][i] = min(dp[node][i], sum);
}
}
int main() {
#pragma warning(disable : 4996)
int n, b;
scanf("%d%d", &n, &b);
memset(dp, 127, sizeof(dp));
;
scanf("%d%d", &c[0], &d[0]);
for (int i = 1; i < n; i++) {
int p;
scanf("%d%d%d", &c[i], &d[i], &p);
v[p - 1].push_back(i);
}
vector<int> a;
cSize(0);
dfs(0, a);
for (int i = 0; i <= n; i++) {
if (dp[0][i + 1] > b) {
printf("%d", i);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void Max(T1& a, T2 b) {
a = max(a, (T1)b);
}
template <typename T1, typename T2>
void Min(T1& a, T2 b) {
a = min(a, (T1)b);
}
const int N = 5000, inf = 1e9 + 1;
vector<long long> g[N];
long long c[N], d[N];
vector<long long> f[N][2];
void calc(long long i) {
vector<long long> t[2];
for (int it = 0; it < (2); ++it) {
bool cur = 0;
t[0].clear();
if (!it)
t[0].push_back(c[i]);
else
t[0].push_back(c[i] - d[i]);
for (auto& e : g[i]) {
cur = !cur;
t[cur].assign(t[!cur].size() + f[e][it].size(), inf);
for (int j = 0; j < (t[!cur].size()); ++j) Min(t[cur][j], t[!cur][j]);
if (!it)
for (int k = 0; k < (f[e][it].size()); ++k) Min(t[cur][k], f[e][it][k]);
for (int j = 0; j < (t[!cur].size()); ++j)
for (int k = 0; k < (f[e][it].size()); ++k)
Min(t[cur][j + k + 1], t[!cur][j] + f[e][it][k]);
}
f[i][it].swap(t[cur]);
}
assert(f[i][0].size() == f[i][1].size());
for (int j = 0; j < (f[i][0].size()); ++j) Min(f[i][1][j], f[i][0][j]);
}
void solve() {
long long n, b, v;
cin >> n >> b;
for (int i = 0; i < (n); ++i) {
cin >> c[i] >> d[i];
if (i) {
cin >> v;
g[--v].push_back(i);
}
}
for (int i = n - 1; i >= (0); --i) calc(i);
long long ans =
upper_bound(f[0][1].begin(), f[0][1].end(), b) - f[0][1].begin();
cout << ans << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
const int Size = 5005;
int n, b, c[Size], d[Size];
struct Edge {
int v, next;
} G[Size << 1];
int cnt, head[Size], siz[Size];
void AddEdge(int u, int v) {
G[++cnt].v = v;
G[cnt].next = head[u];
head[u] = cnt;
}
int dp1[Size][Size], dp2[Size][Size];
void Debug() {
for (int i = 1; i <= n; i++) printf("%d ", dp1[1][i]);
putchar(10);
for (int i = 1; i <= n; i++) printf("%d ", dp2[1][i]);
putchar(10);
}
void dfs(int x) {
dp2[x][0] = 0;
dp1[x][1] = c[x] - d[x];
dp2[x][1] = c[x];
siz[x] = 1;
for (int i = head[x]; i; i = G[i].next) {
int nxt = G[i].v;
dfs(nxt);
for (int j = siz[x]; j >= 0; j--) {
for (int k = 0; k <= siz[nxt]; k++) {
dp1[x][j + k] = min(dp1[x][j + k], dp1[x][j] + dp1[nxt][k]);
dp1[x][j + k] = min(dp1[x][j + k], dp1[x][j] + dp2[nxt][k]);
dp2[x][j + k] = min(dp2[x][j + k], dp2[x][j] + dp2[nxt][k]);
}
}
siz[x] += siz[nxt];
}
}
void init() {
memset(dp1, 0x3f, sizeof(dp1));
memset(dp2, 0x3f, sizeof(dp2));
n = read();
b = read();
c[1] = read();
d[1] = read();
for (int i = 2; i <= n; i++) {
c[i] = read();
d[i] = read();
int fa = read();
AddEdge(fa, i);
}
}
int main() {
init();
dfs(1);
int ans = -1;
for (int i = 1; i <= n; i++) {
if (dp1[1][i] > b && dp2[1][i] > b) {
ans = i - 1;
break;
}
}
printf("%d", ans == -1 ? n : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ob(vector<long long> &a, vector<long long> &b) {
vector<long long> it(a.size() + b.size(), 1e15);
for (int i = it.size() - 1; i >= 0; i--) {
if (i < a.size()) it[i] = a[i];
for (int q = max((long long)0, i - (long long)b.size());
q < a.size() && q + 1 <= i; q++) {
it[i] = min(it[i], a[q] + b[i - q - 1]);
}
}
a = it;
}
pair<vector<long long>, vector<long long>> rek(vector<long long> &cen,
vector<long long> &kyp,
vector<vector<int>> &grap,
long long now) {
pair<vector<long long>, vector<long long>> pai;
vector<long long> a{cen[now] - kyp[now]}, b{cen[now]};
for (int i = 0; i < grap[now].size(); i++) {
pai = rek(cen, kyp, grap, grap[now][i]);
ob(a, pai.first);
for (int q = 0; q < pai.second.size(); q++) {
b.push_back(pai.second[q]);
}
}
sort(b.begin(), b.end());
vector<long long> pr{b[0]};
for (int i = 1; i < b.size(); i++) {
pr.push_back(b[i] + pr[i - 1]);
}
for (int i = 0; i < min(a.size(), b.size()); i++) {
a[i] = min(a[i], pr[i]);
}
return pair<vector<long long>, vector<long long>>{a, b};
}
int main() {
long long n, mon;
cin >> n >> mon;
vector<vector<int>> grap(n);
vector<long long> cen(n), kyp(n);
cin >> cen[0] >> kyp[0];
for (int i = 1; i < n; i++) {
int pr;
cin >> cen[i] >> kyp[i] >> pr;
grap[pr - 1].push_back(i);
}
vector<long long> it = rek(cen, kyp, grap, 0).first;
for (int i = 0; i < it.size(); i++) {
if (it[i] > mon) {
cout << i << "\n";
return 0;
}
}
cout << n;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost[2][5003][5003], b, d[5003], c[5003], N, dp[2][2][5003],
cnt[5003] = {0};
vector<int> adj[5003];
void dfs(int v) {
cnt[v] = 1;
for (int i = 0; i < adj[v].size(); ++i) {
int t = adj[v][i];
dfs(t);
cnt[v] += cnt[t];
}
int cc = 0, p = 1, lim;
if (!adj[v].empty()) {
for (int i = 0; i <= cnt[adj[v][0]]; ++i) {
dp[0][0][i] = cost[0][adj[v][0]][i];
dp[0][1][i] = (((cost[1][adj[v][0]][i]) < (cost[0][adj[v][0]][i]))
? (cost[1][adj[v][0]][i])
: (cost[0][adj[v][0]][i]));
}
lim = cnt[adj[v][0]];
for (int i = 1; i < adj[v].size(); ++i) {
int t = adj[v][i];
cc = (cc ^ 1);
p = (p ^ 1);
for (int j = 1; j <= lim + cnt[t]; ++j) {
dp[cc][0][j] = dp[cc][1][j] = 1000000007ll;
}
for (int j = 0; j <= lim; ++j) {
for (int k = 0; k <= cnt[t]; ++k) {
dp[cc][0][j + k] =
(((dp[cc][0][j + k]) < (cost[0][t][k] + dp[p][0][j]))
? (dp[cc][0][j + k])
: (cost[0][t][k] + dp[p][0][j]));
dp[cc][1][j + k] =
((((((dp[cc][1][j + k]) < (cost[1][t][k] + dp[p][1][j]))
? (dp[cc][1][j + k])
: (cost[1][t][k] + dp[p][1][j]))) <
(cost[0][t][k] + dp[p][1][j]))
? ((((dp[cc][1][j + k]) < (cost[1][t][k] + dp[p][1][j]))
? (dp[cc][1][j + k])
: (cost[1][t][k] + dp[p][1][j])))
: (cost[0][t][k] + dp[p][1][j]));
}
}
lim += cnt[t];
}
} else {
dp[cc][0][1] = dp[cc][1][1] = 1000000007ll;
}
for (int i = 1; i <= cnt[v]; ++i) {
if (i != cnt[v])
cost[0][v][i] = (((dp[cc][0][i - 1] + c[v]) < (dp[cc][0][i]))
? (dp[cc][0][i - 1] + c[v])
: (dp[cc][0][i]));
else
cost[0][v][i] = dp[cc][0][i - 1] + c[v];
if (cost[0][v][i] > b) cost[0][v][i] = 1000000007ll;
cost[1][v][i] = dp[cc][1][i - 1] + c[v] - d[v];
if (cost[1][v][i] > b) cost[1][v][i] = 1000000007ll;
}
}
int main() {
for (int i = 0; i < 5003; ++i) {
for (int j = 0; j < 5003; ++j) {
cost[0][i][j] = cost[1][i][j] = 0;
}
dp[0][0][i] = dp[0][1][i] = dp[1][0][i] = dp[1][1][i] = 0;
}
int n;
scanf("%d %d", &n, &b);
scanf("%d %d", &c[1], &d[1]);
for (int i = 2; i <= n; ++i) {
int p;
scanf("%d %d %d", &c[i], &d[i], &p);
adj[p].push_back(i);
}
dfs(1);
int ans = n;
for (int i = 0; i <= n; ++i) {
if ((((cost[1][1][i]) < (cost[0][1][i])) ? (cost[1][1][i])
: (cost[0][1][i])) > b) {
ans = i - 1;
break;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return;
}
int get() {
char c;
int v;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return v;
}
struct node {
int v;
node *next;
} * adj[5000 + 4], edge[5000 + 4], *CNT = edge;
struct xjb {
int c, d, v;
node *s;
} goods[5000 + 4];
int f[5000 + 4][5000 + 4], g[5000 + 4][5000 + 4];
int subtreesz[5000 + 4];
void addedge(int u, int v) {
node *p = ++CNT;
p->v = v;
p->next = goods[u].s;
goods[u].s = p;
return;
}
void dfs(int s) {
node *p;
int i, j;
f[s][1] = goods[s].d - goods[s].c;
g[s][0] = 0;
g[s][1] = goods[s].d;
subtreesz[s] = 1;
for (p = goods[s].s; p; p = p->next) {
dfs(p->v);
for (i = subtreesz[s]; i >= 0; i--)
for (j = subtreesz[p->v]; j >= 0; j--) {
f[s][i + j] = min(f[s][i + j], f[s][i] + min(f[p->v][j], g[p->v][j]));
g[s][i + j] = min(g[s][i + j], g[s][i] + g[p->v][j]);
}
subtreesz[s] += subtreesz[p->v];
}
return;
}
int main() {
int n, i, ans = 0, Lim;
get(n);
get(Lim);
for (i = 1; i <= n; i++) {
get(goods[i].d);
get(goods[i].c);
if (i > 1) addedge(get(), i);
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
dfs(1);
for (i = 1; i <= n; i++)
if (min(f[1][i], g[1][i]) <= Lim) ans = i;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline int mod(long long x) { return (x %= P) < 0 ? x + P : x; }
long long qpow(long long a, long long n, long long p = P) {
long long r = 1 % p;
for (; n; a = a * a % p, n >>= 1)
if (n & 1) r = r * a % p;
return r;
}
long long inv(long long x) { return x <= 1 ? 1 : inv(P % x) * (P - P / x) % P; }
const int N = 5e3 + 10;
int a[N], b[N], f[N], n, m, k;
vector<int> g[N];
int dp[N][N][2];
int dfs(int x) {
int sz = 0;
for (int y : g[x]) {
int t = dfs(y);
for (int i = sz; i >= 0; --i)
for (int j = 0; j <= t; ++j) {
dp[x][i + j][0] = min(dp[x][i + j][0], dp[y][j][0] + dp[x][i][0]);
dp[x][i + j][1] =
min(dp[x][i + j][1], min(dp[y][j][0], dp[y][j][1]) + dp[x][i][1]);
}
sz += t;
}
++sz;
for (int i = sz; i >= 1; --i) {
dp[x][i][0] = min(dp[x][i][0], dp[x][i - 1][0] + a[x]);
dp[x][i][1] = dp[x][i - 1][1] + b[x];
}
return sz;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", a + i, b + i);
b[i] = a[i] - b[i];
if (i >= 2) {
int t;
scanf("%d", &t);
g[t].push_back(i);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dp[i][j][0] = dp[i][j][1] = 0x3f3f3f3f;
dfs(1);
int ans = 0;
for (int i = 0; i <= n; ++i)
if (dp[1][i][0] <= m || dp[1][i][1] <= m) ans = i;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
struct edge {
int v, next;
} E[maxn];
int n, b, dp[2][maxn][maxn];
int c[maxn], d[maxn], siz[maxn];
int head[maxn], edgecnt;
void init() {
edgecnt = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v) {
E[edgecnt].v = v, E[edgecnt].next = head[u], head[u] = edgecnt++;
}
void dfs(int u) {
siz[u] = 1;
dp[0][u][0] = 0;
dp[0][u][1] = c[u];
dp[1][u][1] = c[u] - d[u];
for (int i = head[u]; ~i; i = E[i].next) {
int v = E[i].v;
dfs(v);
for (int j = siz[u]; j >= 0; j--) {
for (int k = 1; k <= siz[v]; k++) {
dp[0][u][j + k] = min(dp[0][u][j + k], dp[0][u][j] + dp[0][v][k]);
dp[1][u][j + k] = min(dp[1][u][j + k], dp[1][u][j] + dp[0][v][k]);
dp[1][u][j + k] = min(dp[1][u][j + k], dp[1][u][j] + dp[1][v][k]);
}
}
siz[u] += siz[v];
}
}
int main() {
while (~scanf("%d%d", &n, &b)) {
memset(dp, 0x3f, sizeof(dp));
init();
for (int i = 1; i <= n; i++) {
int x;
scanf("%d %d", &c[i], &d[i]);
if (i != 1) {
scanf("%d", &x);
add(x, i);
}
}
dfs(1);
int ans = 0;
for (int i = n; i >= 0; i--) {
if (dp[1][1][i] <= b || dp[0][1][i] <= b) {
ans = i;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int E, head[5050], to[5050], nxt[5050];
void init(int n) {
E = 0;
for (int i = 1; i <= n; i++) head[i] = -1;
}
void add_edge(int u, int v) {
nxt[E] = head[u];
to[E] = v;
head[u] = E++;
}
int dp[2][5050][5050], c[5050], d[5050];
int sz[5050];
void dfs(int u) {
dp[1][u][0] = 0;
dp[0][u][0] = 0;
dp[1][u][1] = c[u] - d[u];
dp[0][u][1] = c[u];
sz[u] = 1;
for (int e = head[u]; ~e; e = nxt[e]) {
int v = to[e];
dfs(v);
for (int i = sz[u] + sz[v]; i >= 1; i--) {
for (int j = min(i, sz[v]); j >= 0 && i - j <= sz[u]; j--) {
smin(dp[0][u][i], dp[0][u][i - j] + dp[0][v][j]);
if (i && j < i) smin(dp[1][u][i], dp[1][u][i - j] + dp[1][v][j]);
}
}
sz[u] += sz[v];
}
for (int i = 1; i <= sz[u]; i++) smin(dp[1][u][i], dp[0][u][i]);
}
int main() {
int n, b;
gn(n, b);
init(n);
memset(dp, 0x3f, sizeof(dp));
for (int i = 1, first; i <= n; i++) {
gn(c[i], d[i]);
if (i > 1) {
gn(first);
add_edge(first, i);
}
}
dfs(1);
int ans = 0;
for (int i = 1; i <= n; i++)
if (dp[1][1][i] <= b) ans = i;
println(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
int n, b;
int get(int x) {
if (x > b)
return b + 1;
else
return x;
}
int c[N], d[N], sz[N];
int dp[N][N][2];
vector<vector<int> > g(N);
void dfs(int v) {
vector<int> p[2];
for (int to : g[v]) {
dfs(to);
p[0].resize(sz[v] + sz[to] + 1, b + 1);
p[1].resize(sz[v] + sz[to] + 1, b + 1);
for (int i = 0; i <= sz[v]; ++i) {
for (int j = 0; j <= sz[to]; ++j) {
p[0][i + j] = min(p[0][i + j], dp[v][i][0] + dp[to][j][0]);
p[0][i + j] = get(p[0][i + j]);
p[1][i + j] = min(
p[1][i + j], min(p[0][i + j], min(dp[v][i][0], dp[v][i][1]) +
min(dp[to][j][0], dp[to][j][1])));
p[1][i + j] = get(p[1][i + j]);
}
}
for (int i = 0; i < p[0].size(); ++i) {
dp[v][i][0] = p[0][i];
dp[v][i][1] = p[1][i];
}
sz[v] += sz[to];
}
sz[v]++;
dp[v][sz[v]][0] = dp[v][sz[v]][1] = b + 1;
for (int i = sz[v]; i > 0; --i) {
dp[v][i][0] = min(dp[v][i][0], dp[v][i - 1][0] + c[v]);
dp[v][i][0] = get(dp[v][i][0]);
dp[v][i][1] = dp[v][i - 1][1] + d[v];
dp[v][i][1] = get(dp[v][i][1]);
}
dp[v][0][1] = b + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n >> b;
for (int i = 1; i <= n; ++i) {
int ci, di;
cin >> ci >> di;
c[i] = ci;
d[i] = c[i] - di;
if (i > 1) {
int p;
cin >> p;
g[p].push_back(i);
}
}
dfs(1);
for (int i = sz[1]; i >= 0; --i) {
if (dp[1][i][0] <= b || dp[1][i][1] <= b) {
cout << i;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mo(long long a) { return a % (long long)(1e9 + 7); }
long long po(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res % p;
}
vector<vector<long long>> g;
vector<long long> c, d, sub;
vector<vector<long long>> dp_cou, dp_no_cou;
void dfs(long long par, long long anc = -1) {
for (long long e : g[par]) {
if (e == anc) continue;
dfs(e, par);
vector<long long> cou(sub[par] + sub[e] + 2, (long long)(1e18 + 5)),
no_cou(sub[par] + sub[e] + 2, (long long)(1e18 + 5));
for (long long i = 0; i <= sub[par]; i++) {
for (long long j = 0; j <= sub[e]; j++) {
cou[i + j] = min(cou[i + j], dp_cou[par][i] + dp_cou[e][j]);
no_cou[i + j] = min(no_cou[i + j], dp_no_cou[par][i] + dp_no_cou[e][j]);
}
}
dp_cou[par] = cou;
dp_no_cou[par] = no_cou;
sub[par] += sub[e];
}
sub[par]++;
for (long long i = sub[par]; i >= 1; i--) {
dp_cou[par][i] = dp_cou[par][i - 1] + d[par];
dp_no_cou[par][i] = min(dp_no_cou[par][i], dp_no_cou[par][i - 1] + c[par]);
dp_cou[par][i] = min(dp_cou[par][i], dp_no_cou[par][i]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, b;
cin >> n >> b;
g.assign(n, {});
c.assign(n, 0);
d.assign(n, 0);
dp_cou.assign(n + 1, vector<long long>(n + 1, (long long)(1e18 + 5)));
dp_no_cou.assign(n + 1, vector<long long>(n + 1, (long long)(1e18 + 5)));
sub.assign(n, 0);
for (long long i = 0; i < n; i++) {
cin >> c[i] >> d[i];
d[i] = c[i] - d[i];
if (i) {
long long x;
cin >> x;
x--;
g[i].push_back(x);
g[x].push_back(i);
}
}
for (int i = 0; i <= n; i++) {
dp_cou[i][0] = 0;
dp_no_cou[i][0] = 0;
}
dfs(0);
long long ans = 0;
for (long long i = 0; i <= n; i++) {
if (dp_cou[0][i] <= b) ans = i;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5050;
int N, B, C[MAXN], D[MAXN], P[MAXN], s[MAXN];
long long dp[MAXN][MAXN], ks[MAXN];
vector<int> child[MAXN], adjList[MAXN];
int main() {
scanf("%d%d", &N, &B);
for (int i = 0; i < N; ++i) {
scanf("%d%d", &C[i], &D[i]);
if (i) {
scanf("%d", &P[i]);
--P[i];
adjList[P[i]].push_back(i);
} else
P[i] = -1;
}
memset(dp, -1, sizeof dp);
for (int x = N - 1; x >= 0; --x) {
child[x].push_back(C[x]);
for (auto it : adjList[x]) {
for (auto k : child[it]) child[x].push_back(k);
}
sort(child[x].begin(), child[x].end());
s[x] = child[x].size();
dp[x][0] = 0;
for (int i = 1; i <= s[x]; ++i) dp[x][i] = dp[x][i - 1] + child[x][i - 1];
ks[0] = 0;
ks[1] = C[x] - D[x];
for (int i = 2; i <= s[x]; ++i) ks[i] = -1;
int sum = 1;
for (auto it : adjList[x]) {
sum += s[it];
for (int v = sum; v > 1; --v) {
for (int k = min(v - 1, s[it]); k > 0; --k) {
if (ks[v - k] == -1) break;
if (ks[v] == -1 || ks[v] > ks[v - k] + dp[it][k])
ks[v] = ks[v - k] + dp[it][k];
}
}
}
for (int v = s[x]; v >= 0; --v) {
dp[x][v] = min(dp[x][v], ks[v]);
if (v < s[x]) {
dp[x][v] = min(dp[x][v + 1], dp[x][v]);
}
}
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (dp[0][i] <= B) ans = i;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
vector<int> adj[5010];
int n, b;
int c[5010], d[5010], sz[5010];
int dp[5010][5010][2];
void dfs(int u) {
sz[u] = 1;
dp[u][0][0] = dp[0][0][1] = 0;
dp[u][1][0] = c[u];
dp[u][1][1] = c[u] - d[u];
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
dfs(v);
for (int j = sz[u] + sz[v]; j >= 1; j--) {
for (int k = min(j, sz[v]); j - k <= sz[u] && k >= 0; k--) {
smin(dp[u][j][0], dp[u][j - k][0] + dp[v][k][0]);
smin(dp[u][j][1], dp[u][j - k][1] + min(dp[v][k][0], dp[v][k][1]));
}
}
sz[u] += sz[v];
}
}
int main() {
gn(n, b);
for (int i = 1; i <= n; i++) {
gn(c[i], d[i]);
if (i > 1) {
int first;
gn(first);
adj[first].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = 0x3f3f3f3f;
}
}
}
dfs(1);
for (int i = n; i >= 0; i--)
if (dp[1][i][0] <= b || dp[1][i][1] <= b) {
println(i);
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return;
}
int get() {
char c;
int v;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return v;
}
struct node {
int v;
node *next;
} * adj[5000 + 4], edge[5000 + 4], *CNT = edge;
struct xjb {
int c, d, v;
node *s;
} goods[5000 + 4];
int f[5000 + 4][5000 + 4], g[5000 + 4][5000 + 4];
int subtreesz[5000 + 4];
void addedge(int u, int v) {
node *p = ++CNT;
p->v = v;
p->next = goods[u].s;
goods[u].s = p;
return;
}
void dfs(int s) {
node *p;
int i, j;
f[s][1] = goods[s].d - goods[s].c;
g[s][0] = 0;
g[s][1] = goods[s].d;
subtreesz[s] = 1;
for (p = goods[s].s; p; p = p->next) {
dfs(p->v);
for (i = subtreesz[s]; i >= 0; i--)
for (j = subtreesz[p->v]; j; j--) {
f[s][i + j] = min(f[s][i + j], f[s][i] + min(f[p->v][j], g[p->v][j]));
g[s][i + j] = min(g[s][i + j], g[s][i] + g[p->v][j]);
}
subtreesz[s] += subtreesz[p->v];
}
return;
}
int main() {
int n, i, ans = 0, Lim;
get(n);
get(Lim);
for (i = 1; i <= n; i++) {
get(goods[i].d);
get(goods[i].c);
if (i > 1) addedge(get(), i);
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
dfs(1);
for (i = 1; i <= n; i++)
if (min(f[1][i], g[1][i]) <= Lim) ans = i;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return;
}
int get() {
char c;
int v;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return v;
}
struct node {
int v;
node *next;
} * adj[5000 + 4], edge[5000 + 4], *CNT = edge;
struct xjb {
int c, d, v;
node *s;
} goods[5000 + 4];
int f[5000 + 4][5000 + 4], g[5000 + 4][5000 + 4];
int subtreesz[5000 + 4];
void addedge(int u, int v) {
node *p = ++CNT;
p->v = v;
p->next = goods[u].s;
goods[u].s = p;
return;
}
void dfs(int s) {
node *p;
int i, j;
f[s][1] = goods[s].d - goods[s].c;
g[s][0] = 0;
g[s][1] = goods[s].d;
subtreesz[s] = 1;
for (p = goods[s].s; p; p = p->next) {
dfs(p->v);
for (i = subtreesz[s]; ~i; i--)
for (j = subtreesz[p->v]; j; j--) {
f[s][i + j] = min(f[s][i + j], f[s][i] + min(f[p->v][j], g[p->v][j]));
g[s][i + j] = min(g[s][i + j], g[s][i] + g[p->v][j]);
}
subtreesz[s] += subtreesz[p->v];
}
return;
}
int main() {
int n, i, Lim;
get(n);
get(Lim);
for (i = 1; i <= n; i++) {
get(goods[i].d);
get(goods[i].c);
if (i > 1) addedge(get(), i);
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
dfs(1);
for (i = 0; i < n && (min(f[1][i + 1], g[1][i + 1]) <= Lim); i++)
;
printf("%d", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 5;
const int inf = 0x3f3f3f3f;
int dp[maxn][maxn][2];
int c[maxn], d[maxn];
vector<int> e[maxn];
int sz[maxn];
void dfs(int u) {
sz[u] = 1;
dp[u][0][0] = 0;
dp[u][1][0] = c[u];
dp[u][1][1] = c[u] - d[u];
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
dfs(v);
for (int j = sz[u]; j >= 0; j--) {
for (int k = 0; k <= sz[v]; k++) {
dp[u][j + k][0] = min(dp[u][j + k][0], dp[u][j][0] + dp[v][k][0]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][1]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][0]);
}
}
sz[u] += sz[v];
}
}
int n, b;
int main() {
memset(dp, inf, sizeof(dp));
scanf("%d%d", &n, &b);
scanf("%d%d", &c[1], &d[1]);
for (int i = 2; i <= n; i++) {
int u;
scanf("%d%d%d", &c[i], &d[i], &u);
e[u].push_back(i);
}
dfs(1);
int ans = 0;
for (int i = n; i >= 0; i--) {
if (dp[1][i][0] <= b || dp[1][i][1] <= b) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
using namespace std;
int dp[N][N][2], n, b, c[N], d[N], x, son[N];
vector<int> adj[N];
void dfs(int u) {
son[u] = 1;
dp[u][0][0] = 0;
dp[u][1][0] = c[u];
dp[u][1][1] = c[u] - d[u];
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
dfs(v);
for (int j = son[u]; j >= 0; j--) {
for (int k = 0; k <= son[v]; k++) {
dp[u][j + k][0] = min(dp[u][j + k][0], dp[u][j][0] + dp[v][k][0]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][1]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][0]);
}
}
son[u] += son[v];
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> b;
cin >> c[1] >> d[1];
for (int i = 2; i <= n; i++) {
cin >> c[i] >> d[i] >> x;
adj[x].push_back(i);
}
memset(dp, 0x3f3f3f3f, sizeof dp);
dfs(1);
int ans = 0;
for (int i = n; i >= 0; i--) {
if (dp[1][i][0] <= b || dp[1][i][1] <= b) {
ans = i;
break;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ReadInt() {
int o = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) o = o * 10 + ch - '0', ch = getchar();
return o;
}
int n, b, q, c[5000 + 10], d[5000 + 10], sz[5000 + 10],
dp[5000 + 10][5000 + 10][2];
vector<int> g[5000 + 10];
void dfs(int u) {
dp[u][0][0] = 0;
dp[u][1][0] = c[u];
dp[u][1][1] = c[u] - d[u];
sz[u] = 1;
for (auto v : g[u]) {
dfs(v);
for (int i = sz[u]; i >= 0; i--) {
for (int j = sz[v]; j >= 0; j--) {
dp[u][i + j][0] = min(dp[u][i + j][0], dp[u][i][0] + dp[v][j][0]);
dp[u][i + j][1] =
min(dp[u][i + j][1], dp[u][i][1] + min(dp[v][j][0], dp[v][j][1]));
}
}
sz[u] += sz[v];
}
}
int main() {
while (~scanf("%d%d", &n, &b)) {
for (int i = 0; i <= n; i++) g[i].clear();
memset(dp, 63, sizeof(dp));
for (int i = 1, x; i <= n; i++) {
c[i] = ReadInt();
d[i] = ReadInt();
if (i >= 2) {
x = ReadInt();
g[x].push_back(i);
}
}
dfs(1);
int ans;
for (int i = 0; i <= n; i++)
if (min(dp[1][i][1], dp[1][i][0]) <= b) ans = i;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void Max(T1& a, T2 b) {
a = max(a, (T1)b);
}
template <typename T1, typename T2>
void Min(T1& a, T2 b) {
a = min(a, (T1)b);
}
const int N = 5000, inf = 1e9 + 1;
vector<long long> g[N];
long long c[N], d[N];
vector<long long> f[N][2];
void calc(long long i) {
for (int it = 0; it < (2); ++it) {
f[i][it].push_back(0);
f[i][it].push_back(c[i] - d[i] * it);
for (auto& e : g[i]) {
long long sz = f[i][it].size();
f[i][it].resize(sz + f[e][it].size() - 1, inf);
for (int j = sz - 1; j >= (it); --j)
for (int k = 1; k <= (f[e][it].size() - 1); ++k)
Min(f[i][it][j + k], f[i][it][j] + f[e][it][k]);
}
}
for (int j = 0; j < (f[i][0].size()); ++j) Min(f[i][1][j], f[i][0][j]);
}
void solve() {
long long n, b, v;
cin >> n >> b;
for (int i = 0; i < (n); ++i) {
cin >> c[i] >> d[i];
if (i) {
cin >> v;
g[--v].push_back(i);
}
}
for (int i = n - 1; i >= (0); --i) calc(i);
long long ans =
upper_bound(f[0][1].begin(), f[0][1].end(), b) - f[0][1].begin() - 1;
cout << ans << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5050;
int n, b, c[MAXN], d[MAXN], fa[MAXN], sum[MAXN], f[MAXN][MAXN], g[MAXN][MAXN];
int buff[MAXN], bufg[MAXN];
int main() {
memset(f, 63, sizeof(f));
memset(g, 63, sizeof(g));
scanf("%d%d", &n, &b);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &d[i]);
if (i > 1) scanf("%d", &fa[i]);
sum[i] = 1;
f[i][1] = c[i] - d[i];
g[i][0] = 0;
g[i][1] = c[i];
if (f[i][1] > b && g[i][1] > b) sum[i] = 0;
}
for (int i = n; i >= 2; i--) {
memcpy(buff, f[fa[i]], sizeof(buff));
memcpy(bufg, g[fa[i]], sizeof(bufg));
for (int j = 0; j <= sum[i]; j++)
for (int k = 0; k <= sum[fa[i]]; k++) {
f[fa[i]][j + k] = min(f[fa[i]][j + k], min(f[i][j], g[i][j]) + buff[k]);
g[fa[i]][j + k] = min(g[fa[i]][j + k], g[i][j] + bufg[k]);
}
sum[fa[i]] += sum[i];
}
for (int i = n; i; --i) {
if (f[1][i] <= b || g[1][i] <= b) {
printf("%d", i);
return 0;
}
}
printf("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 5005, M = 0, Z = 1e9 + 7;
const int inf = 0x3f3f3f3f;
template <class T1, class T2>
inline void gadd(T1 &a, T2 b) {
a = (a + b) % Z;
}
int casenum, casei;
int n, m;
int f[N][N];
int d[N][N];
int v[N];
int c[N];
vector<int> a[N];
int sz[N];
void dfs(int x) {
f[x][0] = d[x][0] = sz[x] = 0;
for (auto y : a[x]) {
dfs(y);
for (int i = sz[x]; ~i; --i) {
for (int j = 1; j <= sz[y]; ++j) {
gmin(f[x][i + j], f[x][i] + f[y][j]);
gmin(f[x][i + j], f[x][i] + d[y][j]);
gmin(d[x][i + j], d[x][i] + d[y][j]);
}
}
sz[x] += sz[y];
}
++sz[x];
for (int i = sz[x]; i; --i) {
f[x][i] = min(f[x][i - 1] + v[x] - c[x], inf);
gmin(d[x][i], d[x][i - 1] + v[x]);
}
}
int szz[N];
void getszz(int x) {
szz[x] = 1;
for (auto y : a[x]) {
getszz(y);
szz[x] += szz[y];
}
}
bool cmp(int x, int y) { return szz[x] < szz[y]; }
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(f, 63, sizeof(f));
memset(d, 63, sizeof(d));
for (int i = 1; i <= n; ++i) {
a[i].clear();
scanf("%d%d", &v[i], &c[i]);
if (i > 1) {
int fa;
scanf("%d", &fa);
a[fa].push_back(i);
}
}
getszz(1);
dfs(1);
for (int i = 1; i <= n; ++i) {
sort(a[i].begin(), a[i].end(), cmp);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (f[1][i] <= m || d[1][i] <= m) {
gmax(ans, i);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct good {
int id;
long long int before;
long long int after;
vector<int> edges;
};
vector<vector<long long int>> dfs(const int now, const vector<good>& goods) {
vector<vector<vector<long long int>>> dps;
int t = 2;
vector<vector<long long int>> dp(2, vector<long long int>(2, 1e18));
dp[0][0] = 0;
dp[1][0] = goods[now].before;
dp[1][1] = goods[now].after;
int m = 2;
for (auto e : goods[now].edges) {
auto adp(move(dfs(e, goods)));
for (int i = 0; i < adp.size() - 1; ++i) {
dp.push_back(vector<long long int>(2, 1e18));
}
for (int i = m - 1; i >= 0; --i) {
for (int j = adp.size() - 1; j >= 0; --j) {
dp[i + j][1] = min(dp[i + j][1], dp[i][1] + min(adp[j][0], adp[j][1]));
dp[i + j][0] = min(dp[i + j][0], dp[i][0] + adp[j][0]);
}
}
m += adp.size() - 1;
}
return dp;
}
int main() {
int N;
cin >> N;
vector<good> goods;
long long int B;
cin >> B;
for (int i = 0; i < N; ++i) {
long long int d, c;
cin >> d >> c;
goods.push_back(good{i, d, d - c, vector<int>()});
if (i) {
int a;
cin >> a;
a--;
goods[a].edges.push_back(i);
}
}
int k = 0;
auto ans = dfs(0, goods);
for (int i = 0; i < ans.size(); ++i) {
for (int j = 0; j < 2; ++j) {
if (ans[i][j] <= B) k = i;
}
}
cout << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int MAXN = 5100;
int c[MAXN], d[MAXN], sz[MAXN];
long long int dp[MAXN][MAXN];
vector<int> v[MAXN];
bool cmp(int a, int b) { return v[a].size() > v[b].size(); }
void cSize(int node) {
sz[node] = 1;
for (int to : v[node]) {
cSize(to);
sz[node] += sz[to];
}
sort(v[node].begin(), v[node].end(), cmp);
}
void dfs(int node, vector<int> &a) {
dp[node][1] = c[node] - d[node];
dp[node][0] = 0;
vector<int> ma;
int s = 1;
for (int to : v[node]) {
dfs(to, ma);
for (int i = s; i >= 1; i--)
for (int j = 1; j <= sz[to]; j++)
dp[node][i + j] = min(dp[node][i + j], dp[node][i] + dp[to][j]);
s += sz[to];
}
ma.push_back(c[node]);
a.insert(a.end(), ma.begin(), ma.end());
sort(ma.begin(), ma.end());
long long int sum = 0;
for (int i = 1; i <= ma.size(); i++) {
sum += ma[i - 1];
dp[node][i] = min(dp[node][i], sum);
}
}
int main() {
#pragma warning(disable : 4996)
int n, b;
scanf("%d%d", &n, &b);
memset(dp, 127, sizeof(dp));
;
scanf("%d%d", &c[0], &d[0]);
for (int i = 1; i < n; i++) {
int p;
scanf("%d%d%d", &c[i], &d[i], &p);
v[p - 1].push_back(i);
}
vector<int> a;
cSize(0);
dfs(0, a);
for (int i = 0; i <= n; i++) {
if (dp[0][i + 1] > b) {
printf("%d", i);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX_N = 305;
const int MOD = 1e9 + 7;
int N, A[MX_N];
int F[MX_N], fcnt, C[MX_N];
int nck[MX_N][MX_N], fac[MX_N], dp[MX_N][MX_N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = (1); i <= (N); ++i) {
cin >> A[i];
for (int j = (1); j <= (i - 1); ++j) {
long long prod = 1LL * A[i] * A[j], rt = sqrt(prod);
if (rt * rt == prod) F[i] = F[j];
}
if (F[i] == 0) F[i] = ++fcnt;
++C[F[i]];
}
for (int x = (0); x <= (N + 1); ++x) {
nck[x][0] = nck[x][x] = 1;
for (int y = (1); y <= (x - 1); ++y) {
nck[x][y] = nck[x - 1][y - 1] + nck[x - 1][y];
if (nck[x][y] >= MOD) nck[x][y] -= MOD;
}
}
fac[0] = 1;
for (int i = (1); i <= (N + 1); ++i) fac[i] = 1LL * fac[i - 1] * i % MOD;
dp[0][0] = 1;
for (int x = (1); x <= (N); ++x) dp[0][x] = 0;
int total = 0;
for (int i = (0); i <= (fcnt - 1); ++i) {
total += C[i];
for (int x = (0); x <= (max(0, total - 1)); ++x) {
for (int s = (1); s <= (min(total + 1, C[i + 1])); ++s) {
for (int q = (0); q <= (min(s, x)); ++q) {
int& nxt = dp[i + 1][x - q + C[i + 1] - s];
nxt += 1LL * dp[i][x] * nck[C[i + 1] - 1][s - 1] % MOD *
fac[C[i + 1]] % MOD * nck[total + 1 - x][s - q] % MOD *
nck[x][q] % MOD;
if (nxt >= MOD) nxt -= MOD;
}
}
}
}
cout << dp[fcnt][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x7f7f7f7f;
const long long INFLL = 0x7f7f7f7f7f7f7f7f;
vector<int> primes;
void init() {
bitset<40000> notprime;
notprime[0] = notprime[1] = true;
for (int i = 2; i < 200; i++) {
if (notprime[i]) {
for (int j = i * i; j < 40000; j += i) notprime[j] = true;
}
}
for (int i = 0; i < 40000; i++)
if (notprime[i] == false) primes.push_back(i);
}
int nonsquare(int n) {
int ans = 1;
int lim = sqrt(n);
for (int i = 0; primes[i] <= lim; i++) {
if (n % primes[i] == 0) {
int count = 0;
while (n % primes[i] == 0) {
n /= primes[i];
count++;
}
if (count % 2 == 1) ans *= primes[i];
}
}
if (n > 1) {
ans *= n;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Easy_DP:
init();
int n;
cin >> n;
int arr[n];
map<int, int> group;
vector<int> count;
for (int i = 0; i < n; i++) {
cin >> arr[i];
int res = nonsquare(arr[i]);
if (!group.count(res)) {
group.insert(pair<int, int>(res, count.size()));
count.push_back(1);
} else {
count[group[res]]++;
}
}
sort(count.begin(), count.end(), greater<int>());
vector<int> num;
vector<int> begin;
int start = 0;
for (int i = 0; i < count.size(); i++) {
for (int j = 0; j < count[i]; j++) {
begin.push_back(start);
num.push_back(i);
}
start += count[i];
}
long long dp[2][n + 2][n + 2];
memset(dp, 0, sizeof(dp));
dp[1][0][0] = 1;
for (int i = 1; i < n; i++) {
if (num[i] != num[i - 1]) {
for (int j = 0; j < i; j++) {
for (int k = 1; k <= j; k++) {
dp[i % 2][j][0] += dp[i % 2][j][k];
dp[i % 2][j][k] = 0;
}
}
}
for (int j = 0; j < i; j++) {
for (int k = 0; k <= j; k++) {
dp[(i + 1) % 2][j + 1][k + 1] =
(dp[(i + 1) % 2][j + 1][k + 1] +
(dp[i % 2][j][k] * (2 * (i - begin[i]) - k)) % MOD) %
MOD;
if (j > 0)
dp[(i + 1) % 2][j - 1][k] =
(dp[(i + 1) % 2][j - 1][k] + (dp[i % 2][j][k] * (j - k)) % MOD) %
MOD;
dp[(i + 1) % 2][j][k] =
(dp[(i + 1) % 2][j][k] +
(dp[i % 2][j][k] * (i + 1 - (2 * (i - begin[i]) - k + j - k))) %
MOD) %
MOD;
}
}
memset(dp[i % 2], 0, sizeof(dp[i % 2]));
}
cout << dp[n % 2][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 700;
int p[40005], c = 0;
bool v[40005];
int n, a[maxn];
int b[maxn], sum[maxn];
long long C[maxn][maxn];
long long dp[maxn][maxn];
long long A[maxn];
void pre() {
for (int i = 2; i < 40005; i++)
if (!v[i]) {
p[c++] = i;
for (int j = 2 * i; j < 40005; j += i) {
v[j] = 1;
}
}
C[0][0] = 1;
A[0] = 1;
for (int i = 1; i < maxn; i++) {
A[i] = (A[i - 1] * i) % mod;
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
}
int main() {
pre();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int now;
scanf("%d", &now);
a[i] = 1;
for (int j = 0; j < c; j++) {
int k = 0;
while (now % p[j] == 0) {
now /= p[j];
k ^= 1;
}
if (k == 1) a[i] *= p[j];
}
a[i] *= now;
}
sort(a, a + n);
int n1 = n;
n = 0;
for (int i = 0; i < n1; i++) {
if (i == 0 || a[i] != a[i - 1]) n++;
b[n]++;
}
dp[1][b[1] - 1] = 1;
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + b[i];
for (int j = 0; j < sum[i]; j++) {
for (int k = 1; k <= b[i + 1]; k++) {
for (int aa = 0; aa <= k; aa++) {
int u = b[i + 1] - k + j - aa;
if (u < 0) continue;
long long cnt = (C[sum[i] + 1 - j][k - aa] * C[j][aa]) % mod;
cnt = (cnt * C[b[i + 1] - 1][k - 1]) % mod;
dp[i + 1][u] = (dp[i + 1][u] + (cnt * dp[i][j]) % mod) % mod;
}
}
}
}
long long ret = dp[n][0];
for (int i = 1; i <= n; i++) {
ret = (ret * A[b[i]]) % mod;
}
printf("%I64d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 200 * 1000 + 16;
int const M = 1000 * 1000 * 1000 + 7;
int n;
int a[320];
int f[616];
int ncr[616][616];
int dp[616][616];
struct dsu {
int fa[500];
dsu(int n) { iota(fa, fa + n + 10, 0); }
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void unite(int x, int y) { fa[find(x)] = find(y); }
};
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
dsu u(n);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
ll x = 1ll * a[i] * a[j];
ll s = sqrt(x) + 0.5;
if (s * s == x) u.unite(i, j);
}
memset(a, 0, sizeof a);
for (int i = 0; i < n; ++i) a[u.find(i)]++;
sort(a, a + n, greater<int>());
int m = find(a, a + n, 0) - a;
for (int i = 0; i < 616; ++i) ncr[i][0] = ncr[i][i] = 1;
for (int i = 1; i < 616; ++i)
for (int j = 1; j < i; ++j)
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % M;
f[0] = 1;
for (int i = 1; i < 616; ++i) f[i] = 1ll * i * f[i - 1] % M;
dp[0][a[0] - 1] = 1;
int k = a[0];
for (int i = 1; i < m; ++i) {
int len = a[i];
for (int p = 0; p < k; ++p) {
int x = dp[i - 1][p];
if (not x) continue;
for (int g = 1; g <= len; ++g) {
for (int u = min({len, p, g}); u >= 0; --u) {
ll y = 1ll * ncr[k - p + 1][g - u] * ncr[p][u] % M;
y *= ncr[len - 1][g - 1];
y %= M;
dp[i][p - u + len - g] += x * y % M;
dp[i][p - u + len - g] %= M;
}
}
}
k += len;
}
int ans = dp[m - 1][0];
for (int i = 0; i < m; ++i) ans = 1ll * ans * f[a[i]] % M;
cout << ans;
}
|
#include <bits/stdc++.h>
const long long N = 305;
const long long MOD = 1e9 + 7;
using namespace std;
long long n, size[N], tot = 0;
long long jie[N], f[N][N], a[N], p[N], ts[N], c[N][N];
long long chk(long long x) {
long long m = sqrt(x);
if (m * m == x) return 1;
return 0;
}
long long cmp(long long x, long long y) { return x > y; }
void pre() {
for (long long i = 0; i <= n; i++) c[i][i] = c[i][0] = 1, c[i][1] = i;
for (long long i = 3; i <= n; i++) {
for (long long j = 2; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
}
jie[1] = 1;
for (long long i = 2; i <= n; i++) jie[i] = jie[i - 1] * i % MOD;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 1; i <= n; i++) {
long long flag = 0;
for (long long grp = 1; grp <= tot; grp++)
if (chk(p[grp] * a[i])) {
size[grp]++;
flag = 1;
break;
}
if (flag == 0) {
tot++;
p[tot] = a[i];
size[tot] = 1;
}
}
sort(size + 1, size + tot + 1, cmp);
pre();
ts[0] = 0;
for (long long i = 1; i <= tot; i++) ts[i] = ts[i - 1] + size[i];
f[0][0] = 1;
long long m = 0;
for (long long i = 1; i <= tot; i++) {
for (long long j = 0; j <= m + 1; j++) {
if (f[i - 1][j] == 0) continue;
for (long long k = 0; k < size[i]; k++) {
long long temp = f[i - 1][j] * c[size[i] - 1][k];
temp %= MOD;
for (long long p = 0; p <= k + 1 && p <= j + size[i] - 1 - k; p++) {
long long temp1 = temp * c[j][p];
temp1 %= MOD;
f[i][j + size[i] - 1 - k - p] +=
(temp1 * c[m + 1 - j][k + 1 - p]) % MOD;
f[i][j + size[i] - 1 - k - p] %= MOD;
}
}
}
m += size[i];
}
for (long long i = 1; i <= tot; i++)
f[tot][0] = (f[tot][0] * jie[size[i]]) % MOD;
printf("%lld", f[tot][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 61;
const long long mod = 1000000007;
const int maxn = 310;
long long f[maxn], invf[maxn], dp[maxn][maxn], a[maxn];
int vis[maxn], cnt[maxn];
long long extgcd(long long a, long long b, long long &x, long long &y);
long long inv(long long a, long long n);
void init();
bool check(long long x);
long long C(int n, int m);
int main() {
std::ios::sync_with_stdio(false);
int i = 0, j = 0, k = 0;
int n, sz = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
memset(vis, 0, sizeof(vis)), memset(cnt, 0, sizeof(cnt));
init();
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
vis[i] = true;
sz++;
cnt[sz] = 1;
for (int j = i + 1; j <= n; j++) {
if (vis[j]) continue;
if (check(a[i] * a[j])) {
vis[j] = true;
cnt[sz]++;
}
}
}
memset(dp, 0, sizeof(dp));
int m = cnt[1] - 1;
dp[1][m] = 1;
for (int i = 2; i <= sz; i++) {
for (int j = 0; j < maxn; j++) {
if (dp[i - 1][j] == 0) continue;
for (int k = 0; k < cnt[i]; k++) {
for (int p = 0; p <= min(k + 1, j); p++) {
long long tmp = dp[i - 1][j] * C(cnt[i] - 1, k) % mod * C(j, p) %
mod * C(m + 2 - j, k + 1 - p) % mod;
dp[i][j + cnt[i] - 1 - k - p] =
(dp[i][j + cnt[i] - 1 - k - p] + tmp) % mod;
}
}
}
m += cnt[i];
}
long long ans = dp[sz][0];
for (int i = 1; i <= sz; i++) ans = ans * f[cnt[i]] % mod;
printf("%lld\n", ans);
return 0;
}
long long C(int n, int m) {
long long ans = 1;
ans = f[n];
ans = ans * invf[m] % mod * invf[n - m] % mod;
return ans;
}
void init() {
f[0] = 1;
invf[0] = inv(1, mod);
for (int i = 1; i < maxn; i++) {
f[i] = f[i - 1] * i % mod;
invf[i] = inv(f[i], mod);
}
}
bool check(long long x) {
long long m = sqrt(x);
for (long long i = max(m - 5, 1LL); i < m + 5; i++) {
if (i * i == x) return true;
}
return false;
}
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1, y = 0;
}
return d;
}
long long inv(long long a, long long n) {
long long d, x, y;
d = extgcd(a, n, x, y);
return d == 1 ? (x + n) % n : -1;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll M = 1e9 + 7;
bool is_square(ll x) {
ll t = sqrt(x);
return t * t == x;
}
int main() {
int n;
cin >> n;
map<ll, ll> cnt;
for (int i = 0; i < n; ++i) {
ll a;
cin >> a;
cnt[a]++;
}
map<ll, vector<int>> num;
for (auto& a : cnt) {
bool update = false;
for (auto& p : num) {
if (is_square(a.first * p.first)) {
num[p.first].push_back(a.second);
update = true;
break;
}
}
if (!update) {
num[a.first].push_back(a.second);
}
}
vector<ll> fact(301);
fact[0] = 1;
for (int i = 1; i <= 300; ++i) {
fact[i] = (fact[i - 1] * i) % M;
}
vector<vector<ll>> comb(301, vector<ll>(301));
for (int i = 0; i < 301; ++i) {
for (int j = 0; j <= i; ++j) {
if (i == j || j == 0) {
comb[i][j] = 1;
} else {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % M;
}
}
}
vector<vector<ll>> dp(num.size() + 1, vector<ll>(n + 1));
dp[0][0] = 1;
ll res = 1;
ll sum = 0;
int i = 0;
for (auto& p : num) {
int m = accumulate(p.second.begin(), p.second.end(), 0);
res = (res * fact[m]) % M;
for (int j = 0; j <= sum; ++j) {
for (int k = 1; k <= m; ++k) {
for (int l = 0; l <= min(j, k); ++l) {
ll t = comb[m - 1][k - 1];
t = (t * comb[j][l]) % M;
t = (t * comb[sum - j + 1][k - l]) % M;
t = (t * dp[i][j]) % M;
(dp[i + 1][j - l + m - k] += t) %= M;
}
}
}
sum += m;
i++;
}
res = (res * dp[num.size()][0]) % M;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x7f7f7f7f;
const long long INFLL = 0x7f7f7f7f7f7f7f7f;
long long egcd(long long a, long long b, long long& x, long long& y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long d = egcd(b, a % b, y, x);
y -= x * (a / b);
return d;
}
vector<long long> inverse;
vector<long long> factorial;
vector<int> primes;
void init() {
factorial.push_back(1);
for (int i = 1; i <= 300; i++) {
factorial.push_back((factorial[i - 1] * i) % MOD);
}
inverse.push_back(-1);
for (int i = 1; i <= 300; i++) {
long long x, y;
egcd(i, MOD, x, y);
inverse.push_back((x + MOD) % MOD);
}
bitset<40000> notprime;
notprime[0] = notprime[1] = true;
for (int i = 2; i < 200; i++) {
if (notprime[i]) {
for (int j = i * i; j < 40000; j += i) notprime[j] = true;
}
}
for (int i = 0; i < 40000; i++)
if (notprime[i] == false) primes.push_back(i);
}
int nonsquare(int n) {
int ans = 1;
int lim = sqrt(n);
for (int i = 0; primes[i] <= lim; i++) {
if (n % primes[i] == 0) {
int count = 0;
while (n % primes[i] == 0) {
n /= primes[i];
count++;
}
if (count % 2 == 1) ans *= primes[i];
}
}
if (n > 1) {
ans *= n;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
lame:
init();
int n;
cin >> n;
int arr[n];
map<int, int> group;
vector<int> count;
for (int i = 0; i < n; i++) {
cin >> arr[i];
int res = nonsquare(arr[i]);
if (!group.count(res)) {
group.insert(pair<int, int>(res, count.size()));
count.push_back(1);
} else {
count[group[res]]++;
}
}
sort(count.begin(), count.end(), greater<int>());
vector<int> num;
vector<int> begin;
int start = 0;
for (int i = 0; i < count.size(); i++) {
for (int j = 0; j < count[i]; j++) {
begin.push_back(start);
num.push_back(i);
}
start += count[i];
}
long long dp[n + 2][n + 2][n + 2];
memset(dp, 0, sizeof(dp));
dp[1][0][0] = 1;
for (int i = 1; i < n; i++) {
if (num[i] != num[i - 1]) {
for (int j = 0; j < i; j++) {
for (int k = 1; k <= j; k++) {
dp[i][j][0] += dp[i][j][k];
dp[i][j][k] = 0;
}
}
}
for (int j = 0; j < i; j++) {
for (int k = 0; k <= j; k++) {
dp[i + 1][j + 1][k + 1] =
(dp[i + 1][j + 1][k + 1] +
(dp[i][j][k] * (2 * (i - begin[i]) - k)) % MOD) %
MOD;
if (j > 0)
dp[i + 1][j - 1][k] =
(dp[i + 1][j - 1][k] + (dp[i][j][k] * (j - k)) % MOD) % MOD;
dp[i + 1][j][k] =
(dp[i + 1][j][k] +
(dp[i][j][k] * (i + 1 - (2 * (i - begin[i]) - k + j - k))) % MOD) %
MOD;
}
}
}
cout << dp[n][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 305;
const long long MOD = 1e9 + 7;
using namespace std;
long long n, size[N], tot = 0;
long long jie[N], f[N][N], a[N], p[N], ts[N], c[N][N];
long long chk(long long x) {
long long m = sqrt(x);
if (m * m == x) return 1;
return 0;
}
long long cmp(long long x, long long y) { return x > y; }
void pre() {
for (long long i = 0; i <= n; i++) c[i][i] = c[i][0] = 1, c[i][1] = i;
for (long long i = 3; i <= n; i++) {
for (long long j = 2; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
}
jie[1] = 1;
for (long long i = 2; i <= n; i++) jie[i] = jie[i - 1] * i % MOD;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 1; i <= n; i++) {
long long flag = 0;
for (long long grp = 1; grp <= tot; grp++)
if (chk(p[grp] * a[i])) {
size[grp]++;
flag = 1;
break;
}
if (flag == 0) {
tot++;
p[tot] = a[i];
size[tot] = 1;
}
}
sort(size + 1, size + tot + 1, cmp);
pre();
ts[0] = 0;
for (long long i = 1; i <= tot; i++) ts[i] = ts[i - 1] + size[i];
f[0][0] = 1;
long long m = 0;
for (long long i = 1; i <= tot; i++) {
for (long long j = 0; j <= m + 1; j++) {
if (f[i - 1][j] == 0) continue;
for (long long k = 0; k < size[i]; k++) {
long long temp = f[i - 1][j] * c[size[i] - 1][k];
temp %= MOD;
for (long long p = 0; p <= k + 1; p++) {
long long temp1 = temp * c[j][p];
temp1 %= MOD;
f[i][j + size[i] - 1 - k - p] +=
(temp1 * c[m + 1 - j][k + 1 - p]) % MOD;
f[i][j + size[i] - 1 - k - p] %= MOD;
}
}
}
m += size[i];
}
for (long long i = 1; i <= tot; i++)
f[tot][0] = (f[tot][0] * jie[size[i]]) % MOD;
printf("%lld", f[tot][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const double pi = acos(-1.0);
int n, a[333], b[333];
long long fac[333], inv[333], f[333][333];
long long Pow(long long x, long long y, long long mo) {
long long ans = 1;
for (; y; x = x * x % mo, y >>= 1)
if (y & 1) ans = ans * x % mo;
return ans;
}
long long C(int n, int m) { return fac[n] * inv[m] % mo * inv[n - m] % mo; }
int main() {
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mo;
inv[n] = Pow(fac[n], mo - 2, mo);
for (int i = n; i >= 1; i--) inv[i - 1] = inv[i] * i % mo;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 2; j <= round(sqrt(a[i] + 0.5)); j++)
while ((a[i] % (j * j)) == 0) a[i] /= j * j;
}
sort(a + 1, a + n + 1);
int m = 1;
b[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) m++;
b[m]++;
}
for (int i = 1; i <= b[1]; i++) f[1][i] = C(b[1] - 1, i - 1);
for (int i = 2; i <= m; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= b[i]; k++)
if (j - k)
f[i][j] =
(f[i][j] + f[i - 1][j - k] * C(j, k) % mo * C(b[i] - 1, k - 1)) %
mo;
long long ans = 0, fff = 1;
for (int i = n; i >= 1; i--) ans = (ans + fff * f[m][i]) % mo, fff *= -1;
for (int i = 1; i <= m; i++) ans = (ans * fac[b[i]]) % mo;
ans = (ans + mo) % mo;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305;
const long long mod = 1e9 + 7;
long long dp[2][maxn];
long long C[maxn][maxn];
long long n, fac[maxn], Inv[maxn];
long long inv(long long a) {
return a == 1 ? 1 : ((mod - mod / a) * inv(mod % a)) % mod;
}
void pre_deal() {
for (int i = 0; i <= 300; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= mod) C[i][j] %= mod;
}
}
fac[0] = Inv[0] = 1;
for (int i = 1; i <= 300; i++)
fac[i] = fac[i - 1] * i % mod, Inv[i] = inv(fac[i]);
}
map<vector<long long>, long long> mp;
int main() {
pre_deal();
cin >> n;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
vector<long long> v;
for (long long d = 2; d * d <= x; d++) {
if (x % d == 0) {
long long jud = 0;
while (x % d == 0) x /= d, jud ^= 1;
if (jud) v.push_back(d);
}
}
if (x > 1) v.push_back(x);
mp[v]++;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
long long now = 0, pre = 1;
for (auto it : mp) {
long long cnt = it.second;
swap(now, pre);
memset(dp[now], 0, sizeof(dp[now]));
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= min(cnt, i); j++) {
dp[now][i] +=
(dp[pre][i - j] *
(((fac[cnt] * Inv[j]) % mod * C[cnt - 1][j - 1]) % mod)) %
mod;
if (dp[now][i] >= mod) dp[now][i] %= mod;
}
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans +=
(((n - i & 1) ? (mod - 1) : 1) % mod * fac[i] % mod) * dp[now][i] % mod;
if (ans >= mod) ans -= mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 305;
const long long MOD = 1e9 + 7;
using namespace std;
long long n, size[N], tot = 0;
long long jie[N], f[N][N], a[N], p[N], ts[N], c[N][N];
long long chk(long long x) {
long long m = sqrt(x);
if (m * m == x) return 1;
return 0;
}
long long cmp(long long x, long long y) { return x > y; }
void pre() {
for (long long i = 0; i <= n; i++) c[i][i] = c[i][0] = 1, c[i][1] = i;
for (long long i = 3; i <= n; i++) {
for (long long j = 2; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
}
jie[1] = 1;
for (long long i = 2; i <= n; i++) jie[i] = jie[i - 1] * i % MOD;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 1; i <= n; i++) {
long long flag = 0;
for (long long grp = 1; grp <= tot; grp++)
if (chk(p[grp] * a[i])) {
size[grp]++;
flag = 1;
break;
}
if (flag == 0) {
tot++;
p[tot] = a[i];
size[tot] = 1;
}
}
sort(size + 1, size + tot + 1, cmp);
pre();
ts[0] = 0;
for (long long i = 1; i <= tot; i++) ts[i] = ts[i - 1] + size[i];
f[0][0] = 1;
for (long long i = 1; i <= tot; i++) {
for (long long j = 0; j <= ts[i - 1] + 1; j++) {
if (f[i - 1][j] == 0) continue;
for (long long k = 1; k <= size[i]; k++) {
for (long long p = 0; p <= k + 1; p++) {
long long yh = f[i - 1][j] * c[j][p] % MOD;
yh = (yh * c[size[i] - 1][k - 1] % MOD) % MOD;
yh = (yh * c[ts[i - 1] + 1 - j][k - p] % MOD);
f[i][j - p + size[i] - k] = (f[i][j - p + size[i] - k] + yh) % MOD;
}
}
}
}
for (long long i = 1; i <= tot; i++)
f[tot][0] = (f[tot][0] * jie[size[i]]) % MOD;
printf("%lld", f[tot][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x;
char c;
while ((c = getchar()) < '0' || c > '9')
;
for (x = c - '0'; (c = getchar()) >= '0' && c <= '9';) x = x * 10 + c - '0';
return x;
}
map<int, int> mp;
int f[2][300 + 5], C[300 + 5][300 + 5];
int main() {
int n = read(), x, i, j, k, ls = 0, s = 0, p = 0, q = 1, v = 1;
for (i = 0; i <= n; ++i)
for (C[i][0] = j = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
for (; n--; ++mp[x])
for (x = read(), i = 2; i * i <= x; ++i)
while (x % (i * i) == 0) x /= i * i;
for (map<int, int>::iterator i = mp.begin(); i != mp.end(); ++i) {
ls = s;
s += i->second;
p ^= 1;
q ^= 1;
memset(f[p], 0, sizeof(f[p]));
for (int i = 2; i <= s - ls; ++i) v = 1LL * v * i % 1000000007;
if (!ls) {
f[p][s - 1] = 1;
continue;
}
for (int i = 0; i < ls; ++i)
if (f[q][i])
for (j = 0; j <= i && j <= s - ls; ++j)
for (k = 0; k <= ls + 1 - i && k <= s - ls - j; ++k)
f[p][i - j + s - ls - j - k] =
(f[p][i - j + s - ls - j - k] +
1LL * f[q][i] * C[i][j] % 1000000007 * C[ls + 1 - i][k] %
1000000007 * C[s - ls - 1][j + k - 1]) %
1000000007;
}
printf("%d", 1LL * f[p][0] * v % 1000000007);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310;
const int MOD = 1000000007;
int n;
int qtdColors;
int v[MAXN];
int anc[MAXN], sz[MAXN];
int freq[MAXN], sFreq[MAXN];
long long int fat[MAXN];
long long int dp[MAXN][MAXN];
long long int choose[MAXN][MAXN];
bool mark[MAXN];
int find(int cur) {
if (anc[cur] == cur) return cur;
return anc[cur] = find(anc[cur]);
}
void join(int i, int j) {
i = find(i);
j = find(j);
if (i == j) return;
if (sz[i] < sz[j]) swap(i, j);
anc[j] = i;
sz[i] += sz[j];
}
bool isPerfectSquare(long long int k) {
long long int r = sqrtl(k);
return (r * r == k);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
fat[0] = 1;
for (int i = 1; i <= n; i++) {
sz[i] = 1;
anc[i] = i;
fat[i] = fat[i - 1] * i;
fat[i] %= MOD;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
long long int p = v[i];
p *= v[j];
if (isPerfectSquare(p)) join(i, j);
}
}
for (int i = 1; i <= n; i++) {
int c = find(i);
if (mark[c]) continue;
mark[c] = true;
freq[++qtdColors] = sz[c];
}
sort(freq + 1, freq + qtdColors + 1);
for (int i = 1; i <= qtdColors; i++) sFreq[i] = sFreq[i - 1] + freq[i];
choose[0][0] = 1;
dp[qtdColors + 1][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
choose[i][j] = choose[i - 1][j] + choose[i - 1][j - 1];
if (choose[i][j] >= MOD) choose[i][j] -= MOD;
}
}
for (int i = qtdColors; i > 0; i--) {
for (int k = 0; k <= sFreq[i - 1]; k++) {
long long int& ans = dp[i][k];
for (int j = 1; j <= freq[i]; j++) {
for (int p = 0; p <= k && p <= j; p++) {
long long int cur = dp[i + 1][k + freq[i] - j - p];
cur *= choose[k][p];
cur %= MOD;
cur *= choose[freq[i] - 1][j - 1];
cur %= MOD;
cur *= choose[sFreq[i - 1] - k + 1][j - p];
cur %= MOD;
ans += cur;
if (ans >= MOD) ans -= MOD;
}
}
ans *= fat[freq[i]];
ans %= MOD;
}
}
printf("%lld\n", dp[1][0]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int f(int x) {
int res = 1;
for (int i = 2; i * i <= x; i++) {
int c = 0;
while (x % i == 0) {
c ^= 1;
x /= i;
}
if (c == 1) res *= i;
}
if (x > 1) res *= x;
return res;
}
int a[N];
int dp[N + 1][N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = f(a[i]);
}
sort(a, a + n);
dp[0][0][0] = 1;
int last = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) {
if (dp[i][j][k] == 0) continue;
int c1 = (i - last) * 2 - k;
int c2 = j;
int c3 = (i + 1) - c1 - c2;
if (c1 > 0) add(dp[i + 1][j][k + 1], (long long)dp[i][j][k] * c1 % MOD);
if (c2 > 0) add(dp[i + 1][j - 1][k], (long long)dp[i][j][k] * c2 % MOD);
if (c3 > 0) add(dp[i + 1][j][k], (long long)dp[i][j][k] * c3 % MOD);
}
if (i == n - 1 || a[i] != a[i + 1]) {
last = i + 1;
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
if (dp[i + 1][j][k] != 0 && k > 0) {
add(dp[i + 1][j + k][0], dp[i + 1][j][k]);
dp[i + 1][j][k] = 0;
}
}
}
cout << dp[n][0][0] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 302, mod = 1e9 + 7;
long long dp[N][N], a[N], prime[N], fac[N], x, y, g, n, b[N], sb = 1, c1, c2,
cnt, sfr;
long long xgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1, gcd = xgcd(b, a % b, x1, y1);
x = y1;
y = x1 - (long long)(a / b) * y1;
return gcd;
}
long long entekhab(long long r, long long n) {
if (r > n) return 0;
if (r == 0) return 1;
long long ans = 1;
ans = fac[n];
x = 1, y = 1, g = xgcd(fac[r], mod, x, y);
ans = (ans * ((x + mod) % mod)) % mod;
x = 1, y = 1, g = xgcd(fac[n - r], mod, x, y);
ans = ((ans * ((x + mod) % mod))) % mod;
return ans;
}
int main() {
fac[0] = 1;
for (long long i = 1; i < N; i++) fac[i] = (fac[i - 1] * i) % mod;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
for (int j = 2; j * j <= a[i]; j++) {
while (a[i] % (j * j) == 0) a[i] = a[i] / (j * j);
}
}
sort(a, a + n);
for (long long i = 0; i < n; i++) {
if (i != 0 && a[i] != a[i - 1]) {
sb++;
b[sb]++;
} else
b[sb]++;
}
a[0] = 0, n = sb + 1;
for (long long i = 1; i < n; i++) a[i] = b[i] + a[i - 1];
dp[1][b[1] - 1] = 1;
for (long long i = 2; i < n; i++) {
for (long long j = 0; j < a[i]; j++) {
for (long long k = 0; k < a[i - 1]; k++) {
for (long long l = max(sfr, k - j); l < min(k, b[i]) + 1; l++) {
c1 = b[i] - l;
c2 = j - (k - l);
c1 -= c2;
if (c1 >= 0) {
cnt = (((dp[i - 1][k] * entekhab(l, k)) % mod) *
entekhab(c1, a[i - 1] - k + 1)) %
mod;
c1 += l;
cnt = (cnt * entekhab(c1 - 1, c1 + c2 - 1)) % mod;
dp[i][j] = (dp[i][j] + cnt) % mod;
}
}
}
}
}
for (long long i = 0; i < n; i++)
dp[n - 1][0] = (dp[n - 1][0] * fac[b[i]]) % mod;
cout << dp[n - 1][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e6 + 88;
const int inf = 1e9 + 88;
const int logn = 22;
const int maxa = 3e6 + 88;
const long long infll = 1e18 + 88;
const char sgl[5] = {'a', 'e', 'i', 'o', 'u'};
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const char sep = 'a' - 1;
const double eps = 1e-9;
int readint() {
long long cur;
scanf("%I64d", &cur);
return cur;
}
int sum(int a, int b) { return (1ll * a + 1ll * b + mod) % mod; }
int umn(int a, int b) { return (1ll * a * b) % mod; }
int g[maxn], a[maxn];
bool used[maxn];
int timer;
int dp[388][388];
int f[maxn], c[388][388];
bool sq(int a, int b) {
long long s = 1ll * a * b;
long long l = 0, r = maxn;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (mid * mid > s)
r = mid - 1;
else
l = mid;
}
return l * l == s;
}
void solve() {
int n, i, j, k, q;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
f[0] = 1;
for (i = 1; i < 388; i++) f[i] = umn(f[i - 1], i);
for (i = 0; i < 388; i++) c[0][i] = 1;
for (i = 1; i < 388; i++)
for (j = 1; j <= i; j++) c[j][i] = sum(c[j][i - 1], c[j - 1][i - 1]);
for (i = 0; i < n; i++)
if (!used[i]) {
used[i] = true;
g[timer] = 1;
for (j = i + 1; j < n; j++)
if (sq(a[i], a[j])) g[timer]++, used[j] = true;
timer++;
}
dp[0][0] = 1;
int all = 1;
for (i = 0; i < timer; i++) {
for (j = 0; j <= all; j++)
if (dp[i][j] != 0) {
for (k = 1; k <= min(g[i], all); k++)
for (q = 0; q <= min(k, j); q++)
dp[i + 1][j - q + g[i] - k] =
sum(dp[i + 1][j - q + g[i] - k],
umn(f[g[i]],
umn(c[q][j], umn(c[k - 1][g[i] - 1],
umn(dp[i][j], c[k - q][all - j])))));
}
all += g[i];
}
cout << dp[timer][0];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const long long int MODULO = 1000000007;
int main() {
int n;
std::cin >> n;
std::vector<long long int> a(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
std::vector<bool> is_used(n, false);
std::vector<int> same_class_sizes;
for (int i = 0; i < n; ++i) {
if (!is_used[i]) {
int class_size = 1;
for (int j = i + 1; j < n; ++j) {
if (a[i] * a[j] == static_cast<long long int>(sqrt(a[i] * a[j])) *
static_cast<long long int>(sqrt(a[i] * a[j]))) {
++class_size;
is_used[j] = true;
}
}
same_class_sizes.push_back(class_size);
}
}
std::vector<std::vector<int>> binom(n + 2);
for (int i = 0; i < n + 2; ++i) {
binom[i].resize(n + 2, 0);
binom[i][0] = (i == 0 ? 1 : 0);
}
for (int i = 1; i < n + 2; ++i) {
for (int j = 0; j < n + 2; ++j) {
if (j >= 1) {
binom[j][i] = binom[j][i - 1] + binom[j - 1][i - 1];
} else {
binom[j][i] = binom[j][i - 1];
}
binom[j][i] %= MODULO;
}
}
std::vector<int> prev_perm_counts(1, 1);
std::vector<int> perm_counts;
int total_numbers_count = 0;
int prev_total_numbers_count = 0;
for (size_t i = 0; i < same_class_sizes.size(); ++i) {
total_numbers_count += same_class_sizes[i];
perm_counts.resize(total_numbers_count + 1, 0);
for (int errors_count = 0; errors_count < total_numbers_count;
++errors_count) {
for (int dropped_errors = 0; dropped_errors < same_class_sizes[i] + 1;
++dropped_errors) {
for (int rest_places = 0;
rest_places < std::min(prev_total_numbers_count + 2,
same_class_sizes[i] - dropped_errors + 1);
++rest_places) {
int new_errors = same_class_sizes[i] - dropped_errors - rest_places;
int old_errors_count = errors_count + dropped_errors - new_errors;
if (old_errors_count >= 0 &&
old_errors_count < prev_total_numbers_count + 1 &&
new_errors >= 0 && new_errors < total_numbers_count + 1 &&
dropped_errors + rest_places >= 1) {
long long int addon = prev_perm_counts[old_errors_count];
addon *= binom[dropped_errors][old_errors_count];
addon %= MODULO;
addon *= binom[rest_places]
[prev_total_numbers_count + 1 - old_errors_count];
addon %= MODULO;
addon *= binom[dropped_errors + rest_places - 1]
[same_class_sizes[i] - 1];
addon %= MODULO;
perm_counts[errors_count] += addon;
perm_counts[errors_count] %= MODULO;
}
}
}
}
prev_total_numbers_count = total_numbers_count;
prev_perm_counts = std::move(perm_counts);
}
std::vector<long long int> factorial(n + 1);
factorial[0] = 1;
for (int i = 1; i < n + 1; ++i) {
factorial[i] = i * factorial[i - 1];
factorial[i] %= MODULO;
}
long long int result;
if (prev_perm_counts.size() == 0) {
result = 1;
} else {
result = prev_perm_counts[0];
}
for (auto& size : same_class_sizes) {
result *= factorial[size];
result %= MODULO;
}
std::cout << result << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void __print(long long x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long MAX = 305;
const long long mod = 1e9 + 7;
long long dp[MAX][MAX];
bool O[MAX];
long long tab[MAX];
long long fact[MAX];
vector<long long> colors;
bool kwadrat(long long a, long long b) {
long long mul = a * b;
long long x = sqrt(mul);
while (x * x > mul) x--;
while (x * x < mul) x++;
return (x * x == mul);
}
long long fastpow(long long a, long long b) {
long long wynik = 1;
while (b) {
if (b & 1) wynik = (wynik * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return wynik;
}
long long division(long long a, long long b) {
return (a * fastpow(b, mod - 2)) % mod;
}
long long binom(long long a, long long b) {
if (b > a) return 0;
long long mina = (fact[b] * fact[a - b]) % mod;
return division(fact[a], mina);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
fact[0] = 1;
for (long long i = 1; i < MAX; i++) fact[i] = (fact[i - 1] * i) % mod;
for (long long i = 1; i <= n; i++) cin >> tab[i];
for (long long i = 1; i <= n; i++) {
if (O[i]) continue;
O[i] = true;
long long cnt = 1;
for (long long j = i + 1; j <= n; j++) {
if (kwadrat(tab[i], tab[j])) O[j] = true, cnt++;
}
colors.push_back(cnt);
}
long long sum = n;
n = colors.size();
dp[0][0] = 1;
long long all = 1, add = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j <= sum; j++) {
if (dp[i][j])
for (long long k = 1; k <= colors[i]; k++) {
long long mul = (dp[i][j] * binom(colors[i] - 1, k - 1)) % mod;
for (long long r = 0; r <= k; r++) {
add = (((mul * binom(j, r)) % mod) * binom(all - j, k - r)) % mod;
if (add)
dp[i + 1][j + colors[i] - k - r] =
(add + dp[i + 1][j + colors[i] - k - r]) % mod;
}
}
}
all += colors[i];
}
for (long long i = 0; i < n; i++)
dp[n][0] = (dp[n][0] * fact[colors[i]]) % mod;
cout << dp[n][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 755, P = 1e9 + 7;
int n, m, a[N], b[N], c[N], s[N];
long long comb[N][N], f[N][N], fac[N], factor[N];
void pre() {
int i, j;
comb[0][0] = 1ll;
for (i = 1; i <= n; ++i) {
comb[i][0] = 1;
for (j = 1; j <= i; ++j)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % P;
}
fac[0] = 1;
for (i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % P;
}
void solve() {
int i, sum = 0, j, k, l;
f[1][c[1] - 1] = 1;
for (i = 1; i + 1 <= m; ++i) {
sum += c[i];
for (j = 0; j + i <= sum; ++j) {
if (!f[i][j]) continue;
for (k = 1; k <= min(c[i + 1], sum + 1); ++k) {
for (l = 0; l <= k; ++l) {
f[i + 1][j + (c[i + 1] - k) - l] +=
f[i][j] * comb[j][l] % P * comb[sum + 1 - j][k - l] % P *
comb[c[i + 1] - k + k - 1][k - 1] % P;
f[i + 1][j + (c[i + 1] - k) - l] %= P;
}
}
}
}
long long ans = f[m][0];
for (i = 1; i <= m; ++i) (ans *= fac[c[i]]) %= P;
printf("%lld\n", ans);
}
bool check(long long a, long long b) {
long long x = round(sqrt(1.0 * a * b)), d;
for (d = -1; d <= 1; ++d)
if ((x + d) * (x + d) == a * b) return true;
return false;
}
int main(int argc, char *argv[]) {
int i, j, p;
scanf("%d", &n);
pre();
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 1; i <= n; ++i) {
if (!b[i])
b[i] = ++m;
else
continue;
c[m] = 1;
for (j = i + 1; j <= n; ++j)
if (check(a[i], a[j])) ++c[m], b[j] = m;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int ar1[305];
class UnionFind {
private:
vector<int> p, rank, setSize;
int numSets;
public:
UnionFind(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
long long int bigmod(long long int a, long long int p) {
if (p == 1) return a % 1000000007;
if (p % 2) return (a * bigmod(a, p - 1)) % 1000000007;
long long int c = bigmod(a, p / 2);
return (c * c) % 1000000007;
}
long long int factn[1000], invfactn[1000];
long long int factm[1000], invfactm[1000];
void init(int n) {
factn[0] = 1;
invfactn[0] = 1;
for (long long int i = 1; i <= n; i++)
factn[i] = (factn[i - 1] * i) % 1000000007;
for (long long int i = 1; i <= n; i++)
invfactn[i] = (invfactn[i - 1] * bigmod(i, 1000000007 - 2)) % 1000000007;
return;
}
void init2(int n) {
factm[0] = 1;
invfactm[0] = 1;
for (long long int i = 1; i <= n; i++)
factm[i] = (factm[i - 1] * i) % 1000000007;
for (long long int i = 1; i <= n; i++)
invfactm[i] = (invfactm[i - 1] * bigmod(i, 1000000007 - 2)) % 1000000007;
return;
}
long long int nCr(int n, int r) {
if (n < 0) return 0;
if (n < r) return 0;
long long int res = (invfactn[n - r] * invfactn[r]) % 1000000007;
res = (res * factn[n]) % 1000000007;
return res;
}
long long int nPr2(int n, int r) {
long long int res = (invfactm[n - r]) % 1000000007;
res = (res * factm[n]) % 1000000007;
return res;
}
vector<int> vec1;
long long int dp[305][305];
long long int call(int i, int bad, int n, int total) {
if (i == n) return (bad == 0);
long long int &ret = dp[i][bad];
if (ret != -1) return ret;
ret = 0;
int cur_total = total + vec1[i];
int gaps = total + 1;
for (int split = 1; split <= min(gaps, vec1[i]); split++) {
for (int chosen_bad_gap = 0; chosen_bad_gap <= min(bad, split);
chosen_bad_gap++) {
int good_gaps = gaps - chosen_bad_gap;
int new_bad = bad - chosen_bad_gap + vec1[i] - split;
int good_splits = split - chosen_bad_gap;
long long int temp = 1;
temp = (nCr(vec1[i] - 1, split - 1) * factn[vec1[i]]) % 1000000007;
temp = (temp * nCr(bad, chosen_bad_gap)) % 1000000007;
temp = (temp * nCr(gaps - bad, good_splits)) % 1000000007;
temp = (temp * call(i + 1, new_bad, n, total + vec1[i])) % 1000000007;
ret = (ret + temp) % 1000000007;
}
}
return ret;
}
int main() {
map<int, int> Map;
int n, k;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &ar1[i]);
Map[ar1[i]]++;
}
UnionFind uf(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
double a = sqrt(ar1[i] * ar1[j]);
if (floor(a) == ceil(a)) uf.unionSet(i, j);
}
init(n + 2);
int s = uf.numDisjointSets();
set<int> S;
for (int i = 0; i < n; i++) S.insert(uf.findSet(i));
vector<int> x;
for (set<int>::iterator it = S.begin(); it != S.end(); it++) x.push_back(*it);
for (int i = 0; i < x.size(); i++) vec1.push_back(uf.sizeOfSet(x[i]));
memset(dp, -1, sizeof(dp));
long long int res = call(0, 0, x.size(), 0);
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using llint = long long;
int n, m, a[600], c[600][600], mom[600];
llint f[600][600], inv[600 + 1], fac[600 + 1];
vector<int> g;
int dfs(int i) {
int res = 1;
mom[i] = 1;
for (int j = 0; j < n; ++j) {
if (c[i][j] == 0 || mom[j] == 1) {
continue;
}
res += dfs(j);
}
return res;
}
void pre() {
fac[0] = fac[1] = 1;
for (int i = 2; i <= 600; ++i) {
fac[i] = fac[i - 1] * i;
if (fac[i] >= 1000000007) {
fac[i] %= 1000000007;
}
}
inv[0] = inv[1] = 1;
for (int i = 2; i <= 600; ++i) {
inv[i] =
(1000000007 - (1000000007 / i) * inv[1000000007 % i] % 1000000007) %
1000000007;
}
for (int i = 2; i <= 600; ++i) {
inv[i] *= inv[i - 1];
if (inv[i] >= 1000000007) {
inv[i] %= 1000000007;
}
}
}
llint ncom(llint k, llint n) {
if (k > n) {
return 0;
}
llint res = fac[n];
res *= inv[n - k];
if (res >= 1000000007) {
res %= 1000000007;
}
res *= inv[k];
if (res >= 1000000007) {
res %= 1000000007;
}
return res;
}
void update(int i, int p) {
if (f[i][p] > 0) {
int s = g[i];
int n = g[i + 1] - s;
for (int l = 1; l <= min(n, s + 1); ++l) {
for (int r = 0; r <= min(p, l); ++r) {
llint &res = f[i + 1][(p - r) + (n - l)];
llint t = fac[n] * f[i][p] % 1000000007;
t = t * ncom(r, p) % 1000000007;
t = t * ncom(l - r, s + 1 - p) % 1000000007;
t = t * ncom(n - l, n - 1) % 1000000007;
res = (res + t) % 1000000007;
}
}
}
}
int main() {
pre();
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
llint M = (llint)a[i] * a[j];
llint r = sqrt(M);
while (r * r < M) {
r += 1;
}
if (r * r == M) {
c[i][j] = c[j][i] = 1;
}
}
}
for (int i = 0; i < n; ++i) {
if (mom[i] == 1) {
continue;
}
g.emplace_back(dfs(i));
}
m = g.size();
for (int i = 1; i < m; ++i) {
g[i] += g[i - 1];
}
f[0][g[0] - 1] = fac[g[0]];
for (int i = 0; i + 1 < m; ++i) {
for (int j = 0; j < g[i]; ++j) {
update(i, j);
}
}
cout << f[m - 1][0] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> sim[305], coba;
int bapak[305];
int arr[305];
int ini[305];
long long f[305][305], fakt[305], inv[305], kali[305], power[305];
long long comb[305][305];
void gabung(int a, int b) {
int x = bapak[a];
int y = bapak[b];
if (x != y) {
if (sim[x].size() < sim[y].size()) {
for (int i = 0; i < sim[x].size(); i++) {
sim[y].push_back(sim[x][i]);
bapak[sim[x][i]] = y;
}
sim[x].clear();
} else {
for (int i = 0; i < sim[y].size(); i++) {
sim[x].push_back(sim[y][i]);
bapak[sim[y][i]] = x;
}
sim[y].clear();
}
}
}
int main() {
int n;
cin >> n;
comb[0][0] = 1;
comb[1][1] = 1;
comb[1][0] = 1;
for (int i = 2; i <= 300; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
comb[i][j] = 1;
else {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007;
}
}
}
fakt[0] = 1;
for (int i = 1; i <= 300; i++) {
fakt[i] = (fakt[i - 1] * i) % 1000000007;
}
for (int i = 1; i <= 300; i++) {
kali[i] = fakt[i];
inv[i] = 1;
}
int now = 1, is = 1000000007 - 2;
while (now <= is) {
if ((now & is) > 0) {
for (int i = 1; i <= 300; i++) {
inv[i] = (inv[i] * kali[i]) % 1000000007;
}
}
for (int i = 1; i <= 300; i++) {
kali[i] = (kali[i] * kali[i]) % 1000000007;
}
now *= 2;
}
for (int i = 1; i <= n; i++) {
bapak[i] = i;
sim[i].push_back(i);
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
long long kali = (long long)arr[i] * arr[j];
long long akar = sqrt(kali);
if (akar * akar == kali) {
gabung(i, j);
}
}
}
int nyak = 0;
for (int i = 1; i <= n; i++) {
if (sim[i].size() != 0) {
ini[nyak] = sim[i].size();
power[nyak] = fakt[ini[nyak]];
coba.clear();
for (int j = 0; j < sim[i].size(); j++) {
coba.push_back(arr[sim[i][j]]);
}
sort(coba.begin(), coba.end());
int ban = 0;
for (int j = 0; j < coba.size(); j++) {
if (j == 0 || coba[j] == coba[j - 1]) {
ban++;
} else {
power[nyak] = (power[nyak] * inv[ban]) % 1000000007;
ban = 1;
}
}
power[nyak] = (power[nyak] * inv[ban]) % 1000000007;
nyak++;
}
}
memset(f, 0, sizeof(f));
f[0][0] = 1;
int total = 0;
for (int now = 0; now < nyak; now++) {
for (int pis = 0; pis < total + 1; pis++) {
if (f[now][pis] == 0) continue;
for (int s = 1; s <= min(total + 1, ini[now]); s++) {
for (int d = 0; d <= min(pis, s); d++) {
long long tambah =
(comb[ini[now] - 1][s - 1] * comb[pis][d]) % 1000000007;
tambah = (tambah * comb[total + 1 - pis][s - d]) % 1000000007;
tambah = (tambah * fakt[ini[now]]) % 1000000007;
tambah = (tambah * f[now][pis]) % 1000000007;
f[now + 1][pis - d + ini[now] - s] =
(f[now + 1][pis - d + ini[now] - s] + tambah) % 1000000007;
}
}
}
total += ini[now];
}
cout << f[nyak][0] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 310;
const int mod = 1e9 + 7;
long long C[maxn][maxn], Fact[maxn];
void init() {
C[0][0] = 1, Fact[0] = 1;
for (int i = 1; i < maxn; i++) {
C[i][0] = 1, Fact[i] = Fact[i - 1] * i % mod;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
long long num[maxn], emp[maxn], dp[maxn][maxn];
int main() {
init();
int n;
scanf("%d", &n);
int tot = 0;
for (int i = 1; i <= n; i++) {
long long tmp;
scanf("%lld", &tmp);
int key = 1;
for (int j = 1; j <= tot; j++) {
long long x = (sqrt(tmp * emp[j]) + 0.5);
if (x * x == tmp * emp[j]) key = 0, num[j]++;
}
if (key) ++tot, num[tot] = 1, emp[tot] = tmp;
}
dp[0][0] = 1;
int m = 0;
for (int i = 1; i <= tot; i++) {
for (int j = 0; j <= n - 1 && j <= m + 1; j++) {
if (dp[i - 1][j] == 0) continue;
for (int k = 1; k <= num[i]; k++) {
long long tmp = dp[i - 1][j] * C[num[i] - 1][k - 1] % mod;
for (int p = 0; p <= k && p <= j + num[i] - k; p++) {
long long temp = tmp * C[j][p] % mod;
dp[i][j + num[i] - k - p] =
(dp[i][j + num[i] - k - p] + temp * C[m + 1 - j][k - p] % mod) %
mod;
}
}
}
m += num[i];
}
long long ans = dp[tot][0];
for (int i = 1; i <= tot; i++) ans = ans * Fact[num[i]] % mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 309;
const long long INF = 1e9 + 7;
long long bin(long long a, long long b) {
if (b == 0) {
return 1;
} else {
long long res = bin(a, b / 2);
res = res * res % INF;
if (b % 2 == 1) {
res = res * a % INF;
}
return res;
}
}
long long fact[4 * maxN];
long long rev[4 * maxN];
map<long long, long long> mp;
long long equiv[maxN];
long long d[4 * maxN][maxN];
static bool was[4 * maxN][maxN];
long long get_c(long long a, long long b) {
return (long long)fact[a] * rev[a - b] % INF * rev[b] % INF;
}
long long lazy(long long windows, long long i, long long num) {
if (i == num - 1) {
if (windows == equiv[i]) {
return 1;
} else {
return 0;
}
}
if (was[windows][i]) {
return d[windows][i];
}
long long res = 0;
for (long long k = 0; k <= min(windows - 1, equiv[i]); k++) {
for (long long j = 0; j <= min(equiv[i] - k, (windows - k) * 2); j++) {
res =
(res +
(long long)get_c(windows, k) * get_c((windows - k) * 2, j) % INF *
get_c(equiv[i] - j - k + (windows - k) - 1, equiv[i] - j - k) %
INF * lazy((windows - k) + equiv[i] - j - k, i + 1, num) % INF) %
INF;
}
}
d[windows][i] = res;
was[windows][i] = true;
return d[windows][i];
}
int main() {
fact[0] = 1;
for (long long i = 1; i < 4 * maxN; i++) {
fact[i] = (long long)fact[i - 1] * i % INF;
}
for (long long i = 0; i < 4 * maxN; i++) {
rev[i] = bin(fact[i], INF - 2);
}
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
bool truth = false;
long long need;
for (auto b : mp) {
long long key = b.first;
long long res = key * a;
long long l = 1, r = INF;
while (l + 1 != r) {
long long m = (l + r) / 2;
if (res < m * m) {
r = m;
} else {
l = m;
}
}
if (l * l == res) {
need = key;
truth = true;
break;
}
}
if (!truth) {
mp[a] = 1;
} else {
mp[need]++;
}
}
long long nxt = 0;
for (auto b : mp) {
equiv[nxt++] = b.second;
}
long long res = lazy(1, 0, nxt);
for (long long i = 0; i < nxt; i++) {
res = res * fact[equiv[i]] % INF;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 302, mod = 1e9 + 7;
long long dp[N][N], a[N], prime[N], fac[N], x, y, g, n, b[N], sb = 1, c1, c2,
cnt, sfr;
long long xgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1, gcd = xgcd(b, a % b, x1, y1);
x = y1;
y = x1 - (long long)(a / b) * y1;
return gcd;
}
long long entekhab(long long r, long long n) {
if (r > n) return 0;
if (r == 0) return 1;
long long ans = 1;
ans = fac[n];
x = 1, y = 1, g = xgcd(fac[r], mod, x, y);
ans = (ans * ((x + mod) % mod)) % mod;
x = 1, y = 1, g = xgcd(fac[n - r], mod, x, y);
ans = ((ans * ((x + mod) % mod))) % mod;
return ans;
}
int main() {
fac[0] = 1;
for (long long i = 1; i < N; i++) fac[i] = (fac[i - 1] * i) % mod;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
for (int j = 2; j * j <= a[i]; j++) {
while (a[i] % (j * j) == 0) a[i] = a[i] / (j * j);
}
}
sort(a, a + n);
for (long long i = 0; i < n; i++) {
if (i != 0 && a[i] != a[i - 1]) {
sb++;
b[sb]++;
} else
b[sb]++;
}
a[0] = 0, n = sb + 1;
for (long long i = 1; i < n; i++) a[i] = b[i] + a[i - 1];
dp[1][b[1] - 1] = 1;
for (long long i = 2; i < n; i++) {
for (long long j = 0; j < a[i]; j++) {
for (long long k = 0; k < a[i - 1]; k++) {
for (long long l = max(sfr, k - j); l < min(k, b[i]) + 1; l++) {
c1 = b[i] - l;
c2 = j - (k - l);
c1 -= c2;
if (c1 >= 0) {
cnt = (((dp[i - 1][k] * entekhab(l, k)) % mod) *
entekhab(c1, a[i - 1] - k + 1)) %
mod;
c1 += l;
cnt = (cnt * entekhab(c1 - 1, c1 + c2 - 1)) % mod;
dp[i][j] = (dp[i][j] + cnt) % mod;
}
}
}
}
}
for (long long i = 0; i < n; i++)
dp[n - 1][0] = (dp[n - 1][0] * fac[b[i]]) % mod;
cout << dp[n - 1][0];
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[310];
long long fac[310], rev[310];
bool mmp[310][310];
long long mod = (long long)1e9 + 7;
long long qmod(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
p /= 2;
}
return ret;
}
void Init() {
fac[0] = 1;
for (int i = 1; i < 310; ++i) fac[i] = fac[i - 1] * i;
rev[0] = 1;
for (int i = 1; i < 310; ++i) rev[i] = qmod(fac[i], mod - 2);
}
long long C(int n, int m) { return fac[n] * rev[m] % mod * rev[n - m] % mod; }
bool isSqure(long long q) {
long long sq = (long long)sqrt(q);
return sq * sq == q;
}
void input() {
istream& in = cin;
in >> n;
for (int i = 1; i <= n; ++i) in >> a[i];
}
bool vis[310];
int dfs(int p) {
if (vis[p]) return 0;
vis[p] = 1;
int ret = 1;
for (int i = 1; i <= n; ++i) {
if (mmp[p][i]) {
ret += dfs(i);
}
}
return ret;
}
int num[310];
long long dp[310][310][310];
bool END[310];
void add(long long& a, long long b) {
a %= mod;
b %= mod;
a = (a + b) % mod;
}
int main() {
input();
Init();
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
if (isSqure(a[i] * a[j])) {
mmp[i][j] = mmp[j][i] = 1;
}
}
vector<int> block;
for (int i = 1; i <= n; ++i) {
int ret = dfs(i);
if (ret) block.push_back(ret);
}
sort(block.begin(), block.end());
reverse(block.begin(), block.end());
int sum = 0;
for (int p : block) {
for (int i = 1; i <= p; ++i) num[sum + i] = i;
sum += p;
END[sum] = 1;
}
dp[0][0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= n + 1; ++j)
for (int k = 0; k <= n + 1; ++k) {
long long& ref = dp[i - 1][j][k];
if (dp[i - 1][j][k] == 0) continue;
int allslot = i;
int prewa = j - k;
int nowwa = k;
int nookwaslot = (num[i] - 1) * 2 - 2 * nowwa;
int okslot = allslot - j - nookwaslot;
if (!END[i]) {
if (j > 0) add(dp[i][j - 1][k], dp[i - 1][j][k] * prewa);
add(dp[i][j + 1][k + 1], dp[i - 1][j][k] * nowwa);
add(dp[i][j][k], dp[i - 1][j][k] * okslot);
add(dp[i][j + 1][k + 1], dp[i - 1][j][k] * nookwaslot);
} else {
if (j > 0) add(dp[i][j - 1][0], dp[i - 1][j][k] * prewa);
add(dp[i][j + 1][0], dp[i - 1][j][k] * nowwa);
add(dp[i][j][0], dp[i - 1][j][k] * okslot);
add(dp[i][j + 1][0], dp[i - 1][j][k] * nookwaslot);
}
}
cout << dp[n][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ans, binom[510][510], a[510], dp[510][510], grNum, grSize[510],
f[510];
const long long mod = 1e9 + 7;
void fix(long long &a) {
a %= mod;
if (a < 0) {
a += mod;
}
}
void getBin() {
for (long long i = 0; i < 510; ++i) {
binom[i][0] = 1;
}
for (long long i = 1; i < 510; ++i) {
for (long long j = 1; j <= i; ++j) {
binom[i][j] = (binom[i - 1][j] + binom[i - 1][j - 1]);
fix(binom[i][j]);
}
}
f[0] = 1;
for (long long i = 1; i < 510; ++i) {
f[i] = f[i - 1] * i;
fix(f[i]);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n;
getBin();
for (long long i = 0; i < n; ++i) {
long long tmp;
cin >> tmp;
for (long long j = 2; j * j <= tmp; ++j) {
while ((tmp % (j * j)) == 0) {
tmp /= (j * j);
}
}
a[i] = tmp;
}
sort(a, a + n);
grNum = 1;
grSize[grNum - 1]++;
for (long long i = 1; i < n; ++i) {
if (a[i] == a[i - 1]) {
grSize[grNum - 1]++;
} else {
grSize[grNum]++;
++grNum;
}
}
dp[0][grSize[0] - 1] = 1;
for (long long total = grSize[0], i = 1; i < grNum; total += grSize[i], ++i) {
for (long long j = 0; j < total; ++j) {
for (long long numSeg = 1; numSeg <= grSize[i]; ++numSeg) {
for (long long solvedPairs = 0; solvedPairs <= min(j, numSeg);
++solvedPairs) {
long long tmp = 0;
tmp += dp[i - 1][j] * binom[grSize[i] - 1][numSeg - 1];
fix(tmp);
tmp *= binom[j][solvedPairs];
fix(tmp);
tmp *= binom[total + 1 - j][numSeg - solvedPairs];
fix(tmp);
tmp *= f[grSize[i - 1]];
fix(tmp);
dp[i][j + grSize[i] - numSeg - solvedPairs] += tmp;
fix(dp[i][j + grSize[i] - numSeg - solvedPairs]);
}
}
}
}
dp[grNum - 1][0] *= f[grSize[grNum - 1]];
fix(dp[grNum - 1][0]);
cout << dp[grNum - 1][0] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 510;
long long fac[maxn];
long long dp[maxn][maxn];
long long c[maxn][maxn];
long long a[maxn], cnt[maxn];
bool vis[maxn];
long long n, sz;
bool perfect_square(long long x) {
long long l = 1, r = 1e9;
long long now = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (mid * mid <= x) {
now = mid;
l = mid + 1;
} else
r = mid - 1;
}
return now * now == x;
}
void get_comb() {
c[0][0] = 1;
fac[0] = 1;
for (long long i = 1; i <= 300; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
for (long long i = 1; i <= 300; i++) fac[i] = (fac[i - 1] * i) % mod;
}
void slove() {
dp[0][cnt[0] - 1] = 1;
long long lim = cnt[0];
for (long long i = 1; i < sz; i++) {
for (long long j = 0; j < lim; j++) {
for (long long k = 0; k < cnt[i]; k++) {
for (long long m = 0; m <= min(j, k + 1); m++) {
long long ways = c[cnt[i] - 1][k] % mod * c[j][m] % mod *
c[lim - 1 - j + 2][k + 1 - m] % mod;
dp[i][j + cnt[i] - 1 - k - m] =
(dp[i][j + cnt[i] - 1 - k - m] + dp[i - 1][j] * ways % mod) % mod;
}
}
}
lim += cnt[i];
}
long long ans = dp[sz - 1][0];
for (long long i = 0; i < sz; i++) {
ans *= fac[cnt[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
scanf("%I64d", &n);
for (long long i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (long long i = 0; i < n; i++) {
if (vis[i] == 0) {
for (long long j = i; j < n; j++) {
if (perfect_square(1LL * a[i] * a[j])) {
cnt[sz]++;
vis[j] = 1;
}
}
sz++;
}
}
get_comb();
slove();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long z = 1;
int c[305][305], fac[305], sum[305], a[305], v[305], f[305][305], tot, sz;
int pd(int a, int b) {
long long c = z * a * b, j;
j = sqrt(c);
return j * j == c;
}
int main() {
int i, j, k, l, n, m;
for (i = 0; i <= 300; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
for (fac[0] = i = 1; i <= 300; i++) fac[i] = z * fac[i - 1] * i % mod;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
if (v[i]) continue;
sum[++tot] = 1;
v[i] = 1;
for (j = i + 1; j <= n; j++) {
if (pd(a[i], a[j])) v[j] = 1, sum[tot]++;
}
}
f[0][0] = 1;
for (i = 1; i <= tot; i++) {
for (j = 0; j <= n; j++) {
for (k = 1; k <= sum[i]; k++) {
for (l = 0; l <= k; l++) {
if (j + sum[i] - k - l >= 0) {
f[i][j + sum[i] - k - l] =
(f[i][j + sum[i] - k - l] +
z * f[i - 1][j] * fac[sum[i]] % mod * c[sum[i] - 1][k - 1] %
mod * c[j][l] % mod * c[sz + 1 - j][k - l]) %
mod;
}
}
}
}
sz += sum[i];
}
printf("%d", f[tot][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gli() {
long long a;
scanf("%I64d", &a);
return a;
}
long long p[10000];
int isp[32000];
int l;
unordered_map<int, int> m;
long long c[304][304];
long long f[304];
long long dp[304][304];
int pw(long long a, int b) {
if (b == 0) return 1;
long long x = pw(a, b / 2);
long long v = (x * x) % 1000000007;
if (b % 2) return (v * a) % 1000000007;
return v;
}
int red(int a) {
for (int i = 0; i < l && a > 1; i++) {
int v = p[i] * p[i];
while (a % v == 0) a /= v;
}
return a;
}
int main() {
l = 1;
p[0] = 2;
memset(isp, -1, sizeof(isp));
for (int i = 3; i < 32000; i += 2)
if (isp[i]) {
p[l++] = i;
for (int j = i * 3; j < 32000; j += 2 * i) isp[j] = 0;
}
f[0] = 1;
for (int i = 0; i < 304; i++) {
if (i) f[i] = (f[i - 1] * i) % 1000000007;
for (int j = 0; j <= i; j++) {
long long x = f[i];
x *= pw(f[j], 1000000007 - 2);
x %= 1000000007;
x *= pw(f[i - j], 1000000007 - 2);
x %= 1000000007;
c[i][j] = x;
}
}
int n = gi();
unordered_map<int, int>::iterator it;
for (int i = 0; i < n; i++) {
int x = red(gi());
if ((it = m.find(x)) == m.end())
m[x] = 1;
else
it->second++;
}
l = 0;
for (it = m.begin(); it != m.end(); it++) p[l++] = it->second;
memset(dp, 0, sizeof(dp));
long long s = p[0];
dp[0][s - 1] = f[s];
for (int i = 1; i < l; i++) {
long long pv = p[i];
for (int j = 0; j <= s - i; j++)
if (dp[i - 1][j])
for (int np = 1; np <= pv; np++) {
long long w =
(((f[pv] * dp[i - 1][j]) % 1000000007) * c[pv - 1][np - 1]) %
1000000007;
for (int kill = ((0) > (np - s - 1 + j) ? (0) : (np - s - 1 + j));
kill <= np && kill <= j; kill++) {
dp[i][j - kill + pv - np] +=
(((w * c[j][kill]) % 1000000007) * c[s + 1 - j][np - kill]) %
1000000007;
dp[i][j - kill + pv - np] %= 1000000007;
}
}
s += pv;
}
printf("%d\n", (int)dp[l - 1][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x7f7f7f7f;
const long long INFLL = 0x7f7f7f7f7f7f7f7f;
vector<int> primes;
void init() {
bitset<40000> notprime;
notprime[0] = notprime[1] = true;
for (int i = 2; i < 200; i++) {
if (notprime[i]) {
for (int j = i * i; j < 40000; j += i) notprime[j] = true;
}
}
for (int i = 0; i < 40000; i++)
if (notprime[i] == false) primes.push_back(i);
}
int nonsquare(int n) {
int ans = 1;
int lim = sqrt(n);
for (int i = 0; primes[i] <= lim; i++) {
if (n % primes[i] == 0) {
int count = 0;
while (n % primes[i] == 0) {
n /= primes[i];
count++;
}
if (count % 2 == 1) ans *= primes[i];
}
}
if (n > 1) {
ans *= n;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Easy_DP:
init();
int n;
cin >> n;
int arr[n];
map<int, int> group;
vector<int> count;
for (int i = 0; i < n; i++) {
cin >> arr[i];
int res = nonsquare(arr[i]);
if (!group.count(res)) {
group.insert(pair<int, int>(res, count.size()));
count.push_back(1);
} else {
count[group[res]]++;
}
}
sort(count.begin(), count.end(), greater<int>());
vector<int> num;
vector<int> begin;
int start = 0;
for (int i = 0; i < count.size(); i++) {
for (int j = 0; j < count[i]; j++) {
begin.push_back(start);
num.push_back(i);
}
start += count[i];
}
long long dp[n + 2][n + 2][n + 2];
memset(dp, 0, sizeof(dp));
dp[1][0][0] = 1;
for (int i = 1; i < n; i++) {
if (num[i] != num[i - 1]) {
for (int j = 0; j < i; j++) {
for (int k = 1; k <= j; k++) {
dp[i][j][0] += dp[i][j][k];
dp[i][j][k] = 0;
}
}
}
for (int j = 0; j < i; j++) {
for (int k = 0; k <= j; k++) {
dp[i + 1][j + 1][k + 1] =
(dp[i + 1][j + 1][k + 1] +
(dp[i][j][k] * (2 * (i - begin[i]) - k)) % MOD) %
MOD;
if (j > 0)
dp[i + 1][j - 1][k] =
(dp[i + 1][j - 1][k] + (dp[i][j][k] * (j - k)) % MOD) % MOD;
dp[i + 1][j][k] =
(dp[i + 1][j][k] +
(dp[i][j][k] * (i + 1 - (2 * (i - begin[i]) - k + j - k))) % MOD) %
MOD;
}
}
}
cout << dp[n][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (int)(1e9) + 7;
long long A[510];
long long C[510][510];
long long dp[310][500];
int n, nn;
int seq[310];
int belong[310], a[310];
void pre() {
A[0] = A[1] = 1;
for (int i = 2; i < 500; ++i) {
A[i] = A[i - 1] * i % mod;
}
for (int i = 0; i < 500; ++i) {
C[0][i] = 1;
for (int j = 1; j <= i; ++j) {
C[j][i] = (C[j][i - 1] + C[j - 1][i - 1]) % mod;
}
}
}
int solve() {
memset(dp, 0, sizeof(dp));
dp[1][seq[1] - 1] = 1;
long long sum = seq[1];
for (int i = 2; i <= n; ++i) {
for (int j = 0; j < sum; ++j) {
for (int k = 1; k <= seq[i]; ++k) {
for (int h = 0; h <= j && h <= k; ++h) {
dp[i][j - h + seq[i] - k] += dp[i - 1][j] * C[h][j] % mod *
C[k - h][sum + 1 - j] % mod *
C[k - 1][seq[i] - 1] % mod;
dp[i][j - h + seq[i] - k] %= mod;
}
}
}
sum += seq[i];
}
long long ret = dp[n][0];
for (int i = 1; i <= nn; ++i) {
ret = ret * A[seq[i]] % mod;
}
return ret;
}
bool ok(int i, int j) {
long long p = (long long)a[i] * a[j];
long long q = sqrt(p);
if (q * q == p)
return 1;
else
return 0;
}
void getseq() {
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
nn = 0;
for (int i = 1; i <= n; ++i) {
if (belong[i] == 0) {
int num = 1;
belong[i] = ++nn;
for (int j = i + 1; j <= n; ++j)
if (ok(i, j)) {
belong[j] = nn;
num++;
}
seq[nn] = num;
}
}
n = nn;
}
int main() {
pre();
scanf("%d", &n);
getseq();
printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void R(int &v) {
static char ch;
v = 0;
bool p = 0;
do {
ch = getchar();
if (ch == '-') p = 1;
} while (!isdigit(ch));
while (isdigit(ch)) {
v = (v + (v << 2) << 1) + (ch ^ '0');
ch = getchar();
}
if (p) v = -v;
}
int a[305];
inline int xiujian(int now) {
int ret = 1, t = now, cnt = 0;
for (int i = 2; i <= sqrt(now); ++i) {
if (t % i == 0) {
cnt = 0;
while (t % i == 0) {
t /= i;
++cnt;
}
if (cnt & 1) {
ret *= cnt;
}
}
}
ret *= t;
return ret;
}
int tot, cnt[305], n;
const int mod = 1e9 + 7;
int c[315][315], dp[315][315];
int qz[315];
bool vis[315];
inline long long mul(long long a, long long b) { return (a * b) % mod; }
inline bool check(long long x) {
long long l = 0, r = 1e9;
while (l < r - 1) {
long long m = (l + r) >> 1;
if (m * m == x) return 1;
if (m * m < x)
l = m;
else
r = m;
}
return 0;
}
int main() {
R(n);
int x;
for (int i = 1; i <= n; ++i) {
R(a[i]);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
tot++;
for (int j = i; j <= n; j++) {
if (check((long long)a[i] * a[j])) vis[j] = 1, cnt[tot]++;
}
}
for (int i = 0; i < 305; ++i) {
c[i][0] = c[i][i] = 1;
}
for (int i = 1; i < 305; ++i) {
for (int j = 1; j < 305; ++j) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
int m = cnt[1] - 1;
dp[1][m] = 1;
for (int i = 2; i <= tot; m += cnt[i++]) {
for (int j = 0; j <= m; ++j) {
if (!dp[i - 1][j]) continue;
for (int k = 0; k < cnt[i]; ++k) {
for (int l = 0; l <= min(k + 1, j); ++l) {
dp[i][j + cnt[i] - l - k - 1] =
(dp[i][j + cnt[i] - l - k - 1] +
mul(mul(mul(dp[i - 1][j], c[j][l]), c[m + 2 - j][k + 1 - l]),
c[cnt[i] - 1][k])) %
mod;
}
}
}
}
int ans = dp[tot][0];
int pow1[305];
pow1[0] = 1;
for (int i = 1; i <= 305; ++i) {
pow1[i] = mul(pow1[i - 1], i);
}
for (int i = 1; i <= tot; ++i) {
ans = mul(ans, pow1[cnt[i]]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long jc[500], inv[500];
long long fpow(long long di, long long top) {
long long ret = 1;
while (top) {
if (top % 2) ret = ret * di % mod;
di = di * di % mod, top /= 2;
}
return ret;
}
void init() {
jc[0] = inv[0] = 1;
for (long long i = 1; i <= 400; ++i) jc[i] = jc[i - 1] * i % mod;
inv[400] = fpow(jc[400], mod - 2);
for (long long i = 399; i >= 1; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
}
long long C(long long k, long long fro) {
if (k > fro) return 0;
if (k == 0) return 1;
long long ret = jc[fro] % mod * inv[fro - k] % mod;
return ret * inv[k] % mod;
}
vector<long long> sth[500];
bool vis[500];
long long siz[500], cnt, n, num[500];
long long dp[510][510];
bool iss(long long a) {
long long nw = sqrt(a);
return 1ll * nw * nw == a;
}
long long tot[500];
signed main() {
cin >> n;
init();
for (long long i = 1; i <= n; ++i) cin >> num[i];
for (long long i = 1; i <= n; ++i) {
if (!vis[i]) {
sth[++cnt].push_back(num[i]), vis[i] = 1;
for (long long j = 1; j <= n; ++j) {
if (!vis[j] && iss(1ll * num[j] * num[i])) {
sth[cnt].push_back(num[j]), vis[j] = 1;
}
}
}
}
for (long long i = 1; i <= cnt; ++i) siz[i] = sth[i].size();
dp[0][0] = 1;
long long tot = 0;
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j <= tot; ++j) {
dp[i - 1][j] %= mod;
if (dp[i - 1][j] == 0) continue;
for (long long k = 1; k <= min(siz[i], tot + 1); ++k) {
for (long long t = 0; t <= min(k, j); ++t) {
long long ndel = 1ll * dp[i - 1][j] * C(k - 1, siz[i] - 1) % mod;
ndel = ndel * C(t, j) % mod;
ndel = ndel * C(k - t, tot + 1 - j) % mod;
dp[i][j - t + siz[i] - k] += ndel;
}
}
}
tot += siz[i];
}
long long ans = dp[cnt][0] % mod;
for (long long i = 1; i <= cnt; ++i) ans = 1ll * ans * jc[siz[i]] % mod;
if (ans < 0) cout << dp[cnt][0];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 510;
long long fac[maxn];
long long dp[maxn][maxn];
long long c[maxn][maxn];
long long a[maxn], cnt[maxn];
bool vis[maxn];
long long n, sz;
bool perfect_square(long long x) {
long long l = 1, r = 1e9;
long long now = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (mid * mid <= x) {
now = mid;
l = mid + 1;
} else
r = mid - 1;
}
return now * now == x;
}
void get_comb() {
c[0][0] = 1;
fac[0] = 1;
for (long long i = 1; i <= 300; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] % mod + c[i - 1][j - 1] % mod) % mod;
}
}
for (long long i = 1; i <= 300; i++) fac[i] = (fac[i - 1] * i) % mod;
}
void slove() {
dp[0][cnt[0] - 1] = 1;
long long lim = cnt[0];
for (long long i = 1; i < sz; i++) {
for (long long j = 0; j < lim; j++) {
for (long long k = 0; k < cnt[i]; k++) {
for (long long m = 0; m <= min(j, k + 1); m++) {
long long ways = c[cnt[i] - 1][k] % mod * c[j][m] % mod *
c[lim - 1 - j + 2][k + 1 - m] % mod;
dp[i][j + cnt[i] - 1 - k - m] =
(dp[i][j + cnt[i] - 1 - k - m] + dp[i - 1][j] * ways % mod) % mod;
}
}
}
lim += cnt[i];
}
long long ans = dp[sz - 1][0];
for (long long i = 0; i < sz; i++) {
ans *= fac[cnt[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
scanf("%I64d", &n);
for (long long i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (long long i = 0; i < n; i++) {
if (vis[i] == 0) {
for (long long j = i; j < n; j++) {
if (perfect_square(1LL * a[i] * a[j])) {
cnt[sz]++;
vis[j] = 1;
}
}
sz++;
}
}
get_comb();
slove();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> ct;
map<int, int> cnt;
long long F[777], IF[777];
inline long long mod_pow(long long a, long long b) {
if (b == 0) return 1;
long long tmp = mod_pow(a, b / 2);
tmp = (tmp * tmp) % 1000000007;
if (b & 1) return (tmp * a) % 1000000007;
return tmp;
}
void init() {
F[0] = 1;
for (int i = 1; i < 777; i++) F[i] = (i * F[i - 1]) % 1000000007;
IF[0] = 1;
IF[777 - 1] = mod_pow(F[777 - 1], 1000000007 - 2);
for (int i = 777 - 2; i > 0; i--) IF[i] = ((i + 1) * IF[i + 1]) % 1000000007;
}
inline long long C(long long n, long long k) {
return (((F[n] * IF[k]) % 1000000007) * IF[n - k]) % 1000000007;
}
long long solve() {
long long F1 = ct[0];
vector<long long> dp(F1, 0);
dp[F1 - 1] = F[F1];
for (int i = 1; i < n; i++) {
long long Fi = ct[i];
vector<long long> next(dp.size() + Fi, 0);
for (int j = 0; j < (int)dp.size(); j++) {
if (dp[j] == 0) continue;
for (int k = 1; k <= min(Fi, (long long)dp.size() + 1); k++) {
for (int l = 0; l <= min(k, j); l++) {
long long exist = dp.size() + 1 - j;
long long need = k - l;
if (need > exist) continue;
long long foo =
(F[Fi] *
((((C(exist, need) * C(j, l)) % 1000000007) * C(Fi - 1, k - 1)) %
1000000007)) %
1000000007;
next[j - l + Fi - k] =
(next[j - l + Fi - k] + (foo * dp[j]) % 1000000007) % 1000000007;
}
}
}
dp = next;
}
return dp[0];
}
inline int get(int x) {
for (int i = 2; i * i <= x; i++) {
while (x % (i * i) == 0) x /= (i * i);
}
return x;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init();
int x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
x = get(x);
cnt[x]++;
}
for (auto elem : cnt) ct.push_back(elem.second);
cnt.clear();
n = ct.size();
cout << solve() << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 310;
const int oo = 1000000000;
const int modulo = 1000000007;
const double ms = 1e-10;
int root[maxn], cnt[maxn], space[maxn];
long long a[maxn], c[maxn][maxn], f[maxn][maxn];
int n, t;
void input() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
}
int getroot(int x) {
if (root[x] == x) return x;
root[x] = getroot(root[x]);
return root[x];
}
void init() {
for (int i = 0; i < n; i++) root[i] = i;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (sqrt(a[i] * a[j]) - (long long)sqrt(a[i] * a[j]) < ms &&
getroot(i) != getroot(j)) {
root[getroot(i)] = getroot(j);
}
for (int i = 0; i < n; i++) cnt[getroot(i) + 1]++;
c[0][0] = 1;
for (int i = 1; i <= n; i++) c[0][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
c[i][j] = (c[i - 1][j - 1] + c[i][j - 1]) % modulo;
for (int i = 1; i <= n; i++)
if (cnt[i] > 0) {
t++;
cnt[t] = cnt[i];
}
for (int i = 1; i <= t; i++) cnt[i] += cnt[i - 1];
}
void solve() {
f[0][0] = 1;
for (int i = 0; i < t; i++)
for (int j = 0; j <= n - 1; j++) {
for (int x = 0; x <= min(j, cnt[i + 1] - cnt[i]); x++)
for (int y = 0; y <= min(cnt[i] - j + 1, cnt[i + 1] - cnt[i] - x); y++)
if (x + y > 0) {
int tg = (j - x) + (cnt[i + 1] - cnt[i] - x - y);
f[i + 1][tg] =
(f[i + 1][tg] + (c[x][j] * c[y][cnt[i] - j + 1] % modulo) *
(c[x + y - 1][cnt[i + 1] - cnt[i] - 1] *
f[i][j] % modulo)) %
modulo;
}
}
}
long long get(int x) {
long long re = 1;
for (int i = 1; i <= x; i++) re = (re * i) % modulo;
return re;
}
void output() {
long long tmp = 1;
for (int i = 1; i <= t; i++) tmp = tmp * get(cnt[i] - cnt[i - 1]) % modulo;
printf("%d", (f[t][0] * tmp) % modulo);
}
int main() {
std::ios::sync_with_stdio(false);
input();
init();
solve();
output();
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
inline void R(int &v) {
static char ch;
v = 0;
bool p = 0;
do {
ch = getchar();
if (ch == '-') p = 1;
} while (!isdigit(ch));
while (isdigit(ch)) {
v = (v + (v << 2) << 1) + (ch ^ '0');
ch = getchar();
}
if (p) v = -v;
}
int a[305];
inline int xiujian(int now) {
int ret = 1, t = now, cnt = 0;
for (int i = 2; i <= sqrt(now); ++i) {
if (t % i == 0) {
cnt = 0;
while (t % i == 0) {
t /= i;
++cnt;
}
if (cnt & 1) {
ret *= cnt;
}
}
}
ret *= t;
return ret;
}
int tot, cnt[305], n;
const int mod = 1e9 + 7;
int c[315][315], dp[315][315];
int qz[315];
bool vis[315];
inline long long mul(long long a, long long b) { return (a * b) % mod; }
inline bool check(long long x) {
long long l = 1, r = 1e9;
while (l <= r) {
long long m = (l + r) >> 1;
if (m * m == x) return 1;
if (m * m < x)
l = m + 1;
else
r = m - 1;
}
return 0;
}
int main() {
R(n);
int x;
for (int i = 1; i <= n; ++i) {
R(a[i]);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
tot++;
for (int j = i; j <= n; j++) {
if (check((long long)a[i] * a[j])) vis[j] = 1, cnt[tot]++;
}
}
for (int i = 0; i < 305; ++i) {
c[i][0] = c[i][i] = 1;
}
for (int i = 1; i < 305; ++i) {
for (int j = 1; j < 305; ++j) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
int m = cnt[1] - 1;
dp[1][m] = 1;
for (int i = 2; i <= tot; m += cnt[i++]) {
for (int j = 0; j <= m; ++j) {
if (!dp[i - 1][j]) continue;
for (int k = 0; k < cnt[i]; ++k) {
for (int l = 0; l <= min(k + 1, j); ++l) {
dp[i][j + cnt[i] - l - k - 1] =
(dp[i][j + cnt[i] - l - k - 1] +
mul(mul(mul(dp[i - 1][j], c[j][l]), c[m + 2 - j][k + 1 - l]),
c[cnt[i] - 1][k])) %
mod;
}
}
}
}
int ans = dp[tot][0];
int pow1[305];
pow1[0] = 1;
for (int i = 1; i <= 305; ++i) {
pow1[i] = mul(pow1[i - 1], i);
}
for (int i = 1; i <= tot; ++i) {
ans = mul(ans, pow1[cnt[i]]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300;
const long long INF = 1000000000LL;
const long long MOD = 1000000007LL;
int arr[N + 1];
long long binom[N + 1][N + 1];
long long facto[N + 1];
int cnt[N + 1];
long long dp[N], tmp[N];
long long modadd(long long, long long);
long long modmul(long long, long long);
long long modmul(initializer_list<long long>);
bool is_perfect(long long);
int main() {
binom[0][0] = facto[0] = 1LL;
for (int i = 1; i <= N; ++i) {
binom[i][0] = binom[i][i] = 1LL;
for (int j = 1; j <= N - 1; ++j) {
binom[i][j] = modadd(binom[i - 1][j - 1], binom[i - 1][j]);
}
facto[i] = modmul(facto[i - 1], i);
}
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &arr[i]);
}
for (int i = 1; i <= n; ++i) {
int j;
for (j = 1; j <= i && !is_perfect(1LL * arr[i] * arr[j]); ++j)
;
++cnt[j];
}
dp[cnt[1] - 1] = facto[cnt[1]];
int holes = cnt[1] + 1;
for (int i = 2; i <= n; ++i) {
if (!cnt[i]) continue;
for (int j = 0; j <= holes - 2; ++j) {
if (!dp[j]) continue;
for (int k = 1; k <= min(cnt[i], holes); ++k) {
for (int l = k - min(holes - j, k); l <= min(j, k); ++l) {
int nextj = j - l + (cnt[i] - k);
tmp[nextj] = modadd(
tmp[nextj],
modmul({dp[j], facto[cnt[i]], binom[cnt[i] - 1][cnt[i] - k],
binom[j][l], binom[holes - j][k - l]}));
}
}
}
holes += cnt[i];
copy(tmp, tmp + n, dp);
fill(tmp, tmp + n, 0);
}
printf("%lld\n", dp[0]);
exit(EXIT_SUCCESS);
}
long long modadd(long long a, long long b) { return (a + b) % MOD; }
long long modmul(long long a, long long b) { return (a * b) % MOD; }
long long modmul(initializer_list<long long> arr) {
long long ret = 1LL;
for (auto x : arr) {
ret = modmul(ret, x);
}
return ret;
}
bool is_perfect(long long x) {
long long left, right;
for (left = 1LL, right = min(x, INF); left < right;) {
long long mid = (left + right + 1LL) / 2LL;
if (mid * mid > x) {
right = mid - 1;
} else {
left = mid;
}
}
return left * left == x;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.