text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, t, i, ans, j;
string s, s1;
map<string, int> m;
string a[20], b[20];
bool f[20][20], v[20];
void dfs(int o) {
if (o > n) {
int p = 0;
for (i = 1; i <= n; ++i) {
if (!v[i]) continue;
p++;
for (j = 1; j <= n; ++j) {
if (!v[j]) continue;
if (f[i][j]) return;
}
}
if (p > ans) {
int oo = 0;
ans = p;
for (i = 1; i <= n; ++i) {
if (v[i]) b[oo++] = a[i];
}
}
return;
}
v[o] = 1;
dfs(o + 1);
v[o] = 0;
dfs(o + 1);
}
int main() {
scanf("%d%d", &n, &t);
for (i = 1; i <= n; ++i) {
cin >> s;
m[s] = i;
a[i] = s;
}
for (i = 1; i <= t; ++i) {
cin >> s >> s1;
f[m[s]][m[s1]] = 1;
f[m[s1]][m[s]] = 1;
}
dfs(1);
printf("%d\n", ans);
sort(b, b + ans);
for (i = 0; i < ans; ++i) {
cout << b[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool G1[20][20];
bool flag[20];
bool t[20];
bool Ans[20];
int ans;
void DFS(int n, int cur, int sum) {
if (n < cur) {
if (sum > ans) {
ans = sum;
for (int i = 1; i <= n; ++i) Ans[i] = t[i];
}
return;
}
if (!flag[cur]) {
queue<int> temp;
flag[cur] = 1;
t[cur] = 1;
for (int i = 1; i <= n; ++i) {
if (!flag[i] && G1[cur][i]) {
flag[i] = 1;
temp.push(i);
}
}
DFS(n, cur + 1, sum + 1);
flag[cur] = 0;
t[cur] = 0;
while (!temp.empty()) {
int u = temp.front();
temp.pop();
flag[u] = 0;
}
}
DFS(n, cur + 1, sum);
}
int main() {
int n, m;
string name[20];
while (cin >> n >> m) {
ans = 0;
memset(G1, 0, sizeof(G1));
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= n; ++i) cin >> name[i];
sort(name + 1, name + n + 1);
string a, b;
while (m--) {
cin >> a >> b;
int u, v;
for (int i = 1; i <= n; ++i) {
if (a == name[i]) u = i;
if (b == name[i]) v = i;
}
G1[u][v] = G1[v][u] = 1;
}
DFS(n, 1, 0);
cout << ans << endl;
for (int i = 1; i <= n; ++i) {
if (Ans[i]) cout << name[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(vector<string> &v, map<string, vector<string> > &mp) {
for (int i = 0; i < v.size(); i++) {
if (mp.find(v[i]) != mp.end()) {
auto it = mp.find(v[i]);
vector<string> v1 = it->second;
for (int j = 0; j < v1.size(); j++) {
for (int k = 0; k < v.size(); k++) {
if (v1[j] == v[k]) return false;
}
}
}
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
vector<string> v, v_max;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
v.push_back(s);
}
map<string, vector<string> > mp;
int mx = 0;
for (int i = 1; i <= m; i++) {
string s, t;
cin >> s >> t;
mp[s].push_back(t);
}
int counter = (1 << n) - 1;
for (int c = 0; c <= counter; c++) {
vector<string> v1;
for (int j = 0; j < v.size(); j++) {
if (c & (1 << j)) v1.push_back(v[j]);
}
if (check(v1, mp)) {
if (v1.size() > mx) {
mx = v1.size();
v_max = v1;
}
}
}
sort(v_max.begin(), v_max.end());
cout << mx << "\n";
for (int i = 0; i < v_max.size(); i++) cout << v_max[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool E[17][17];
map<string, int> M;
void edge(int x, int y) { E[x][y] = E[y][x] = true; }
vector<string> nom;
vector<int> v, ans;
int n, m;
bool compara(int x, int y) { return nom[x] < nom[y]; }
bool val() {
for (int j = 0; j < v.size(); j++)
for (int k = j + 1; k < v.size(); k++)
if (E[v[j]][v[k]]) return false;
return true;
}
char cad[20], cad1[20];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%s", cad), M[string(cad)] = i, nom.push_back(string(cad));
for (int i = 0; i < m; i++)
scanf("%s%s", cad, cad1), edge(M[string(cad)], M[string(cad1)]);
int mayor = 0;
for (int i = 1; i < (1 << n); i++) {
v.clear();
for (int j = 0; j < n; j++)
if ((i >> j) & 1) v.push_back(j);
if (val()) {
if ((int)v.size() > mayor) {
mayor = (int)v.size();
ans.clear();
ans = v;
}
}
}
printf("%d\n", mayor);
sort(ans.begin(), ans.end(), compara);
for (int i = 0; i < ans.size(); i++) printf("%s\n", nom[ans[i]].c_str());
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string members[16];
int hate[16][16] = {{0}};
int bitsIn(int x) {
int bits = 0;
int i = 0;
while (x > 0) {
if (x & 1) bits++;
x = x >> 1;
}
return bits;
}
int solve(int member = 0, int mask = 0) {
if (member == n) return mask;
int takeMask = 0, leaveMask = 0;
for (int i = 0; i < member; i++) {
if (((mask & 1 << i) != 0) && hate[member][i]) {
leaveMask = solve(member + 1, mask);
return leaveMask;
}
}
takeMask = solve(member + 1, mask | 1 << member);
leaveMask = solve(member + 1, mask);
int maxMask = bitsIn(takeMask) >= bitsIn(leaveMask) ? takeMask : leaveMask;
return maxMask;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> members[i];
for (int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
for (int j = 0; j < n; j++) {
if (members[j] == s1) {
for (int k = 0; k < n; k++) {
if (members[k] == s2) {
hate[j][k] = 1;
hate[k][j] = 1;
}
}
}
}
}
int mask = solve();
cout << bitsIn(mask) << endl;
string team[16];
int i = 0, j = 0;
while (mask >= 1 << i) {
if (mask & 1 << i) {
team[j] = members[i];
j++;
}
i++;
}
sort(team, team + j);
for (int i = 0; i < j; i++) cout << team[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TT>
TT abs(TT a) {
if (a < 0) return -a;
return a;
}
template <class ZZ>
ZZ max(ZZ a, ZZ b, ZZ c) {
return max(a, max(b, c));
}
template <class ZZ>
ZZ min(ZZ a, ZZ b, ZZ c) {
return min(a, min(b, c));
}
map<string, int> mp;
map<int, string> imp;
bool mt[20][20];
vector<string> v;
int main() {
int i, j, k, tks, ks = 1, n, m, l;
string ss, s;
while (cin >> n >> m) {
memset(mt, false, sizeof(mt));
mp.clear();
imp.clear();
k = 0;
for (i = 0; i < n; i++) {
cin >> s;
imp[k] = s;
mp[s] = k++;
}
while (m--) {
cin >> s >> ss;
mt[mp[s]][mp[ss]] = true;
mt[mp[ss]][mp[s]] = true;
}
int kk = 0;
for (i = 1; i < (1LL << n); i++) {
l = 1;
for (j = 0; j < n; j++)
if (l)
for (k = 0; k < n; k++)
if ((i & (1LL << j)) && (i & (1LL << k)) && mt[j][k]) {
l = 0;
break;
}
if (!l) continue;
m = (__builtin_popcount(i));
if (m > kk) {
kk = m;
v.clear();
for (j = 0; j < n; j++)
if ((i & (1LL << j))) v.push_back(imp[j]);
}
}
cout << kk << endl;
sort((v).begin(), (v).end());
for (i = 0; i < ((int)v.size()); i++) cout << v[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979;
const double PI2 = 6.28318530717958;
const double PId2 = 1.570796326794895;
inline long long pw(long long n, int p) {
long long ans = 1;
for (int i = 0; i < p; i++) ans *= n;
return ans;
}
inline vector<int> ReadVI(int count) {
vector<int> arrayname(count);
for (int i = 0; i < int(count); i++) cin >> arrayname[i];
return arrayname;
};
inline vector<long long> ReadVlong(int count) {
vector<long long> arrayname(count);
for (int i = 0; i < int(count); i++) cin >> arrayname[i];
return arrayname;
};
const int MOD = 100000000;
const int MAXVALUE = 101;
int n;
vector<vector<int> > d;
bool clique(int mask) {
vector<int> a;
for (int i = 0; i < n; i++)
if (mask & (1 << i)) a.push_back(i);
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a.size(); j++)
if (d[a[i]][a[j]]) return false;
}
return true;
}
int cnt(int mask) {
int r = 0;
for (int i = 0; i < n; i++)
if (mask & (1 << i)) r++;
return r;
}
int main() {
int k;
cin >> n >> k;
string t, t1;
vector<string> names(n);
map<string, int> a;
for (int i = 0; i < n; i++) cin >> names[i];
sort(names.begin(), names.end());
for (int i = 0; i < n; i++) a[names[i]] = i;
d = vector<vector<int> >(n, vector<int>(n, 0));
for (int i = 0; i < k; i++) {
cin >> t >> t1;
d[a[t]][a[t1]] = 1;
d[a[t1]][a[t]] = 1;
}
int m = 0, ans = 0;
for (int i = 1; i <= (1 << n); i++) {
if (clique(i) && cnt(i) > m) m = cnt(i), ans = i;
}
cout << m << endl;
for (int i = 0; i < n; i++) {
if (ans & (1 << i)) cout << names[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
map<string, int> ms;
vector<string> g;
int e[N][N], a[N];
int main() {
int n, m, sz = 1;
cin >> n >> m;
string s, s2;
for (int i = 0; i < n; i++) {
cin >> s;
g.push_back(s);
}
sort(g.begin(), g.end());
for (int i = 0; i < n; i++) ms[g[i]] = i;
memset(e, 0, sizeof(e));
while (m--) {
cin >> s >> s2;
int u = ms[s], v = ms[s2];
e[u][v] = e[v][u] = 1;
}
int all = (1 << n) - 1, k = 0, ans = 0, as;
for (int s = all; s >= 0; s--) {
k = 0;
for (int i = 0; i < n; i++) {
if ((1 << i) & s) a[k++] = i;
}
bool flag = 1;
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
if (e[a[i]][a[j]]) {
flag = 0;
break;
}
}
}
if (flag) {
if (k > ans) ans = k, as = s;
}
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
if ((1 << i) & as) cout << g[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> anss;
int ans;
int combit(int n) {
int k = 0;
while (n) {
k += (n % 2);
n /= 2;
}
return k;
}
map<string, int> mp;
int n, m;
string s, x, y, name[1111];
bool g[111][111], flag;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
name[i] = s;
mp[s] = i;
}
for (int i = 1; i <= m; i++) {
cin >> x >> y;
g[mp[x]][mp[y]] = g[mp[y]][mp[x]] = 1;
}
for (int state = 0; state < (1 << n); state++) {
if (combit(ans) >= combit(state)) continue;
flag = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((state & (1 << i)) && (state & (1 << j)) && g[i][j]) flag = 1;
}
}
if (!flag) ans = state;
}
for (int i = 0; i < n; i++) {
if (ans & (1 << i)) anss.push_back(name[i]);
}
sort(anss.begin(), anss.end());
cout << anss.size() << endl;
for (int i = 0; i < anss.size(); i++) {
cout << anss[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string S[17], s, first, second;
int A[17];
map<string, int> M;
vector<set<int> > V(16);
vector<int> Sol, cur;
void Solve(int i) {
if (i == n) {
if (cur.size() > Sol.size()) Sol = cur;
return;
}
bool Can = true;
for (int j = 0; j < (int)cur.size(); j++) {
if (V[cur[j]].find(i) != V[cur[j]].end()) Can = false;
}
if (Can) {
cur.push_back(i);
Solve(i + 1);
cur.pop_back();
}
Solve(i + 1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
int idx = 1;
for (int i = 0; i < (int)n; i++) {
cin >> S[i];
M[S[i]] = i;
}
while (m--) {
cin >> first >> second;
V[M[first]].insert(M[second]);
V[M[second]].insert(M[first]);
}
Solve(0);
vector<string> Res;
cout << Sol.size() << endl;
for (int i = 0; i < (int)Sol.size(); i++) {
Res.push_back(S[Sol[i]]);
}
sort(Res.begin(), Res.end());
for (int i = 0; i < (int)Sol.size(); i++) {
cout << Res[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long g[20][20];
void solve() {
long long n, m;
cin >> n >> m;
map<long long, string> mp;
map<string, long long> inv;
for (long long i = 0; i < n; ++i) {
string s;
cin >> s;
mp[i] = s;
inv[s] = i;
}
for (long long i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
g[inv[a]][inv[b]] = 1;
g[inv[b]][inv[a]] = 1;
}
vector<string> anss;
for (long long mask = 0; mask < (1 << n); mask++) {
bool ans = true;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (((1 << i) & mask) and ((1 << j) & mask) and g[i][j]) {
ans = false;
break;
}
}
}
if (ans and __builtin_popcount(mask) > anss.size()) {
anss.clear();
for (long long i = 0; i < n; i++)
if (mask & (1 << i)) anss.push_back(mp[i]);
}
}
sort(anss.begin(), anss.end());
cout << anss.size() << '\n';
for (auto x : anss) cout << x << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> names;
string tmp;
for (int i = 0; i <= n - 1; i++) {
cin >> tmp;
names.push_back(tmp);
}
sort(names.begin(), names.end());
map<string, int> mp;
for (int i = 0; i <= n - 1; i++) mp[names[i]] = i;
vector<int> bad;
for (int i = 0; i <= m - 1; i++) {
bad.push_back(0);
cin >> tmp;
bad[i] = 1 << mp[tmp];
cin >> tmp;
bad[i] |= 1 << mp[tmp];
}
int j;
int ans = 0;
for (int i = (1 << n) - 1; i >= 0; i--) {
for (j = 0; j <= m - 1; j++)
if ((i & bad[j]) == bad[j]) break;
if (j == m && __builtin_popcount(ans) < __builtin_popcount(i)) ans = i;
}
cout << __builtin_popcount(ans) << endl;
for (int i = 0; i <= n - 1; i++)
if (ans & (1 << i)) cout << names[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
void dfs(long long src, bool visited[], vector<long long> adj[],
vector<long long> &v) {
visited[src] = true;
v.push_back(src);
for (auto i : adj[src]) {
if (!visited[i]) dfs(i, visited, adj, v);
}
}
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
sort(s.begin(), s.end());
int no[n][n];
memset(no, 0, sizeof(no));
map<string, int> mp;
for (int i = 0; i < n; i++) {
mp[s[i]] = i;
}
vector<pair<int, int>> pp(m);
for (int i = 0; i < m; i++) {
string s, t;
cin >> s >> t;
int x = mp[s];
int y = mp[t];
no[x][y] = 1;
no[y][x] = 1;
}
vector<int> v, ans;
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < n; j++)
if (i & (1 << j)) v.push_back(j);
int temp = 1;
for (int j = 0; j < v.size(); j++) {
for (int k = j + 1; k < v.size(); k++) {
if (no[v[j]][v[k]] == 1) {
temp = 0;
break;
}
}
}
if (temp and v.size() > ans.size()) {
ans = v;
v.clear();
} else {
v.clear();
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << s[ans[i]] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void File_input() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void FastInputOutput() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void Do_stress() {
srand(time(0));
freopen("D:/ACM/submit6/input.txt", "w", stdout);
}
int n, m;
vector<string> names;
string str, hat;
map<string, vector<string> > vec;
int main() {
FastInputOutput();
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> str;
names.push_back(str);
}
for (int i = 0; i < m; i++) {
cin >> str >> hat;
vec[str].push_back(hat);
vec[hat].push_back(str);
}
vector<string> ans, fin;
int Max = 0;
for (int i = (1 << n) - 1; i >= 0; i--) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
if ((int)ans.size() == 0) {
ans.push_back(names[j]);
} else {
bool can = 1;
for (int c = 0; c < (int)ans.size(); c++) {
for (int c1 = 0; c1 < (int)vec[names[j]].size(); c1++) {
if (vec[names[j]][c1] == ans[c]) {
can = 0;
break;
}
}
if (!can) {
break;
}
}
if (can) ans.push_back(names[j]);
}
}
}
if (Max < (int)ans.size()) {
fin.clear();
for (auto j : ans) fin.push_back(j);
Max = (int)ans.size();
}
ans.clear();
}
sort(fin.begin(), fin.end());
cout << Max << "\n";
for (auto i : fin) {
cout << i << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
string name[16];
int nel[1000][2];
int n, m;
int num(int i) {
int kol = 0;
while (i > 0) {
if (i % 2 == 1) ++kol;
i /= 2;
}
return kol;
}
bool check(int ch) {
bool arr[16];
for (int i = 0; i < 16; ++i) arr[i] = 0;
int i = 0;
while (ch > 0) {
arr[i++] = ch % 2;
ch /= 2;
}
for (int i = 0; i < m; ++i)
if (arr[nel[i][0]] && arr[nel[i][1]]) return false;
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> name[i];
for (int i = 0; i < m; ++i) {
string s;
int t1, t2;
cin >> s;
for (int j = 0; j < n; ++j)
if (name[j] == s) t1 = j;
cin >> s;
for (int j = 0; j < n; ++j)
if (name[j] == s) t2 = j;
nel[i][0] = t1;
nel[i][1] = t2;
}
int numm = 0, max = -1;
for (int i = 0; i < 1 << n; ++i) {
if (check(i) && num(i) > max) max = num(i), numm = i;
}
cout << max << endl;
int i = 0;
vector<string> otv;
while (numm > 0) {
if (numm % 2 == 1) otv.push_back(name[i]);
numm /= 2;
++i;
}
sort(otv.begin(), otv.end());
for (int i = 0; i < otv.size(); ++i) cout << otv[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16 + 5;
int n, m;
vector<string> V(N);
vector<vector<string>> F;
vector<int> res;
void bt(vector<int> &tmp, int idx) {
if (idx >= m) {
if (tmp.size() > res.size()) res = tmp;
return;
}
int f1 = -1, f2 = -1;
for (int i = 0; i < tmp.size(); i++) {
if (V[tmp[i]] == F[idx][0]) f1 = i;
if (V[tmp[i]] == F[idx][1]) f2 = i;
}
if (!(f1 != -1 && f2 != -1))
bt(tmp, idx + 1);
else {
int t = tmp[f1];
swap(tmp[f1], tmp[(int)tmp.size() - 1]);
tmp.pop_back();
bt(tmp, idx + 1);
tmp.push_back(t);
swap(tmp[f1], tmp[(int)tmp.size() - 1]);
t = tmp[f2];
swap(tmp[f2], tmp[(int)tmp.size() - 1]);
tmp.pop_back();
bt(tmp, idx + 1);
tmp.push_back(t);
swap(tmp[f2], tmp[(int)tmp.size() - 1]);
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> V[i];
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
F.push_back({a, b});
}
vector<int> tmp;
for (int i = 0; i < n; i++) tmp.push_back(i);
bt(tmp, 0);
vector<string> out;
for (auto i : res) out.push_back(V[i]);
sort(out.begin(), out.end());
cout << out.size() << endl;
for (auto i : out) cout << i << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100], str1[100];
map<string, int> mymap;
int adj[20][20];
int bitone(int num) {
int sum = 0;
while (num) {
num = num & (num - 1);
sum++;
}
return sum;
}
bool judge(int t, int n) {
int res[20];
int j = 0;
for (int i = 0; i < n; i++) {
if (t & (1 << i)) {
res[j++] = i;
}
}
for (int i = 0; i < j; i++) {
for (int k = 0; k < j; k++) {
if (adj[res[i]][res[k]]) {
return false;
}
}
}
return true;
}
struct node {
char s[100];
} st[20];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", str);
mymap[str] = i;
strcpy(st[i].s, str);
}
memset(adj, 0, sizeof(adj));
for (int i = 0; i < m; i++) {
scanf("%s%s", str, str1);
adj[mymap[str]][mymap[str1]] = 1;
adj[mymap[str1]][mymap[str]] = 1;
}
int mx = 1 << n;
int Max = 0;
int pos = -1;
for (int i = 0; i < mx; i++) {
if (judge(i, n)) {
int t = bitone(i);
if (t > Max) {
pos = i;
Max = t;
}
}
}
printf("%d\n", Max);
if (pos != -1) {
int res[20];
int j = 0;
for (int i = 0; i < n; i++) {
if (pos & (1 << i)) {
res[j++] = i;
}
}
vector<string> myv;
for (int i = 0; i < j; i++) {
myv.push_back(st[res[i]].s);
}
sort(myv.begin(), myv.end());
for (int i = 0; i < myv.size(); i++) {
cout << myv[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bestTeam;
void optimize() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int nSetBits(int n) {
unsigned int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int main() {
optimize();
map<string, int> nameToInt;
string name, names[17];
int i, j, n, m, forbidden[289] = {0};
cin >> n >> m;
for (i = 0; i < n; names[i] = name, ++i) cin >> name;
sort(names, names + n);
for (i = 0; i < n; ++i) nameToInt[names[i]] = i;
for (i = 0; i < m; ++i) {
cin >> name;
forbidden[i] |= 1 << nameToInt[name];
cin >> name;
forbidden[i] |= 1 << nameToInt[name];
}
for (int i = (1 << n) - 1; i > 0; --i) {
for (j = 0; j < m; ++j)
if ((forbidden[j] & i) == forbidden[j]) break;
if (j == m && nSetBits(bestTeam) < nSetBits(i)) bestTeam = i;
}
cout << nSetBits(bestTeam) << "\n";
for (i = 0; i < n; ++i)
if (bestTeam & (1 << i)) cout << names[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dX[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dY[] = {1, -1, 0, 0, 1, -1, -1, 1};
int n, m;
string names[20];
vector<int> path;
vector<string> ans;
map<pair<int, int>, bool> edge;
map<string, int> ID;
void check() {
if ((ans.size()) > (path.size())) return;
ans.clear();
for (int i = 0; i < (path.size()); ++i) ans.push_back(names[path[i]]);
}
void solve(int idx) {
if (idx == n) {
check();
return;
}
bool can = 1;
for (int i = 0; i < (path.size()); ++i)
if (edge.count({idx, path[i]})) {
can = 0;
break;
}
if (can) {
path.push_back(idx);
solve(idx + 1);
path.pop_back();
}
solve(idx + 1);
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < n; ++i) cin >> names[i], ID[names[i]] = i;
for (int i = 0; i < m; ++i) {
string s, t;
cin >> s >> t;
edge[{ID[s], ID[t]}] = 1;
edge[{ID[t], ID[s]}] = 1;
}
solve(0);
sort(ans.begin(), ans.end());
printf("%d\n", (ans.size()));
for (int i = 0; i < (ans.size()); ++i) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<string> ans, cek;
map<string, int> mp;
vector<string> daftar;
int n, m;
int i, j, k, l;
int ok = 1, mx = -1;
string in, in1, in2;
vector<pair<int, int> > dt;
scanf("%d %d", &n, &m);
daftar.resize(n);
int id = n - 1;
for (i = n - 1; i >= 0; i--) {
cin >> in;
mp[in] = i;
daftar[i] = in;
}
if (m == 0) {
printf("%d\n", n);
for (map<string, int>::const_iterator it = mp.begin(); it != mp.end(); ++it)
cout << it->first << endl;
return 0;
}
for (i = 0; i < m; i++) {
cin >> in1 >> in2;
dt.push_back(make_pair(mp[in1], mp[in2]));
}
int bts = (int)(dt).size();
for (i = (1 << n) - 1; i >= 0; i--) {
bitset<16> bb(i);
ok = 1;
for (j = 0; j < bts; j++) {
if (bb[dt[j].first] && bb[dt[j].second]) {
ok = 0;
break;
}
}
if (ok) {
cek.clear();
for (k = 0; k < (int)(bb).size(); k++) {
if (bb[k]) {
cek.insert(daftar[k]);
}
}
if ((int)(cek).size() > mx) {
mx = (int)(cek).size();
ans = cek;
}
}
}
printf("%d\n", (int)(ans).size());
for (set<string>::const_iterator it = ans.begin(); it != ans.end(); ++it)
cout << *it << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<string, int> nameMap;
vector<int> markedPairs;
vector<string> names;
vector<string> sortedSubset;
string name1, name2;
for (int i = 0; i < n; i++) {
cin >> name1;
nameMap[name1] = i;
names.push_back(name1);
}
for (int i = 0; i < m; ++i) {
int pair = 0;
cin >> name1 >> name2;
pair = pair | (1 << nameMap[name1]);
pair = pair | (1 << nameMap[name2]);
markedPairs.push_back(pair);
}
int limit = 1 << n;
int maxSubset = -1;
int maxCounter = 0;
for (int j = 0; j < limit; j++) {
int subset = j;
bool isValidSubset = true;
for (int i = 0; i < m; ++i) {
if ((markedPairs[i] & subset) == markedPairs[i]) {
isValidSubset = false;
break;
}
}
if (isValidSubset) {
int counter = __builtin_popcount(subset);
if (counter > maxCounter) {
maxSubset = subset;
maxCounter = counter;
}
}
}
cout << maxCounter << endl;
int k = 0;
while (maxSubset) {
if (maxSubset & 1) {
sortedSubset.push_back(names[k]);
}
maxSubset >>= 1;
k++;
}
sort(sortedSubset.begin(), sortedSubset.end());
for (int i = 0; i < maxCounter; i++) {
cout << sortedSubset[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string na[20], v, vi;
int ed[20][20];
vector<string> cur, ans;
map<string, int> nu;
void test() {
for (int i = 0; i < ((int)((cur).size())); ++i)
for (int j = 1 + i; j < ((int)((cur).size())); j++)
if (ed[nu[cur[j]]][nu[cur[i]]]) return;
if (((int)((cur).size())) > ((int)((ans).size()))) ans = cur;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); ++i) {
cin >> na[i];
nu[na[i]] = i;
}
for (int i = 0; i < (int)(m); ++i) {
cin >> v >> vi;
ed[nu[v]][nu[vi]] = ed[nu[vi]][nu[v]] = 1;
}
for (int i = 0; i < (int)((1 << n)); ++i) {
cur.clear();
for (int j = 0; j < (int)(n); ++j)
if (i & (1 << j)) cur.push_back(na[j]);
test();
}
cout << ((int)((ans).size())) << endl;
sort(((ans).begin()), ((ans).end()));
for (int i = 0; i < ((int)((ans).size())); ++i) cout << ans[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const double eps = 1e-9;
const double pi = acos(-1.0);
const long long inf = 1ll << 60;
const int mod = 1e9 + 7;
string s1, s2;
map<string, int> id;
map<int, string> name;
bool M[18][18];
int main() {
memset((M), (false), sizeof(M));
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> s1, id[s1] = i, name[i] = s1;
for (int i = 0; i < m; i++)
cin >> s1 >> s2, M[id[s1]][id[s2]] = M[id[s2]][id[s1]] = true;
pair<int, int> res = make_pair(-1, -1);
bool ok;
for (int i = 0, cnt = 0; i < (1 << n); i++, cnt = 0) {
ok = true;
for (int j = 0; j < n and ok; j++)
if (i & (1 << j)) {
for (int h = 0; h < n and ok; h++)
if ((i & (1 << h)) and M[j][h]) ok = false;
++cnt;
}
if (ok and cnt > res.second) res.first = i, res.second = cnt;
}
vector<string> ans;
for (int i = 0; i < n; i++)
if (res.first & (1 << i)) ans.push_back(name[i]);
sort((ans).begin(), (ans).end());
printf("%d\n", (int)(ans).size());
for (int i = 0; i < (int)(ans).size(); i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool agg[16][16];
int main() {
int n, m, p, q;
string a[16], x, y;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> x >> y;
for (int j = 0; j < n; j++)
if (x == a[j])
p = j;
else if (y == a[j])
q = j;
agg[p][q] = agg[q][p] = true;
}
vector<int> v, ans;
int maxi = 0;
bool ind = true;
for (int i = 1; i < (2 << n); i++) {
ind = true;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) v.push_back(j);
for (int j = 0; j < v.size(); j++)
for (int k = j + 1; k < v.size(); k++)
if (agg[v[j]][v[k]]) ind = false;
if (ind) {
if (maxi < v.size()) maxi = v.size(), ans = v;
}
v.clear();
}
cout << maxi << endl;
for (int i = 0; i < maxi; i++) {
cout << a[ans[i]] << endl;
}
}
|
#include <bits/stdc++.h>
const int N = 17;
int a[N][N], n, m, best, bestn;
std::string s, t, S[N];
char buff[20];
std::map<std::string, int> M;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", buff);
s = buff;
M[s] = i;
S[i] = s;
}
for (int i = 0; i < m; ++i) {
scanf("%s", buff);
s = buff;
scanf("%s", buff);
t = buff;
a[M[s]][M[t]] = a[M[t]][M[s]] = 1;
}
for (int i = 0; i < (1 << n); ++i) {
bool bad = false;
int num = 0;
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) {
for (int k = 0; k < n; ++k) {
if (i & (1 << k)) {
bad |= a[j][k];
}
}
num++;
}
}
if (!bad && num > bestn) {
best = i, bestn = num;
}
}
std::vector<std::string> answer;
for (int i = 0; i < n; ++i) {
if (best & (1 << i)) {
answer.push_back(S[i]);
}
}
std::sort(answer.begin(), answer.end());
printf("%d\n", (int)answer.size());
for (int i = 0; i < (int)answer.size(); i++) {
printf("%s\n", answer[i].c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> nameToInt;
string names[(16 + 1)];
int n, m, forbidden[(16 + 1) * (16 + 1)], bestTeam;
string name;
int nSetBits(int i) { return __builtin_popcount(i); }
int main() {
int i, j;
cin >> n >> m;
for (i = 0; i < n; names[i] = name, ++i) cin >> name;
sort(names, names + n);
for (i = 0; i < n; ++i) nameToInt[names[i]] = i;
for (i = 0; i < m; ++i) {
forbidden[i] = 0;
cin >> name;
forbidden[i] |= 1 << nameToInt[name];
cin >> name;
forbidden[i] |= 1 << nameToInt[name];
}
for (int i = (1 << n) - 1; i > 0; --i) {
for (j = 0; j < m; ++j)
if ((forbidden[j] & i) == forbidden[j]) break;
if (j == m && nSetBits(bestTeam) < nSetBits(i)) bestTeam = i;
}
cout << nSetBits(bestTeam) << endl;
for (i = 0; i < n; ++i)
if (bestTeam & (1 << i)) cout << names[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt[17];
string name[17];
vector<int> conflic[17];
vector<int> res, cur;
bool cmp(int a, int b) { return name[a] < name[b]; }
void dfs(int now) {
if (n - now + (int)cur.size() < (int)res.size()) return;
if (now == n) {
if (cur.size() > res.size()) res = cur;
return;
}
if (!cnt[now]) {
for (int &c : conflic[now]) ++cnt[c];
cur.push_back(now);
dfs(now + 1);
for (int &c : conflic[now]) --cnt[c];
cur.pop_back();
}
dfs(now + 1);
}
int main() {
map<string, int> id;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> name[i];
id[name[i]] = i;
}
for (int i = 0, u, v; i < m; ++i) {
string a, b;
cin >> a >> b;
u = id[a];
v = id[b];
conflic[u].push_back(v);
conflic[v].push_back(u);
}
dfs(0);
cout << res.size() << '\n';
sort(res.begin(), res.end(), cmp);
for (int &i : res) cout << name[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int ROW[] = {+0, +0, -1, +1};
int COL[] = {+1, -1, +0, +0};
int X[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int Y[] = {-1, +1, +0, +0, +1, +1, -1, -1};
int KX[] = {-2, -2, -1, -1, 1, 1, 2, 2};
int KY[] = {-1, 1, -2, 2, -2, 2, -1, 1};
vector<string> v;
string s;
bool mat[20][20];
map<string, int> mp;
bool isvalid(int num, int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int temp = mat[i][j];
if ((num & (1 << i)) && (num & (1 << j)) && mat[i][j]) return false;
}
}
return true;
}
int digcnt(int num) {
int cnt = 0;
while (num) {
if (num & 1) cnt++;
num >>= 1;
}
return cnt;
}
string tosmall(string s) {
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = s[i] - 'A' + 'a';
}
}
return s;
}
bool cmp(string a, string b) {
string c = tosmall(a);
string d = tosmall(b);
if (c < d)
return true;
else if (d > c)
return false;
else
return a < b;
}
int main() {
int n, m, id = 0, ans = 0, x, y, val = 0;
cin >> n >> m;
for (int i = n - 1; i >= 0; i--) {
cin >> s;
v.push_back(s);
}
sort(v.begin(), v.end());
for (auto it : v) mp[it] = id++;
for (int i = 0; i < m; i++) {
cin >> s;
x = mp[s];
cin >> s;
y = mp[s];
mat[x][y] = true;
mat[y][x] = true;
}
for (int i = (1 << n) - 1; i > 0; i--) {
if (isvalid(i, n)) {
if (digcnt(i) > val)
val = digcnt(i);
else
continue;
ans = i;
}
}
cout << val << endl;
for (int i = 0; i < n; i++) {
if (ans & (1 << i)) cout << v[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, res = 0;
map<string, int> mp;
map<int, string> inv;
vector<string> ans;
bool graph[16][16];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
mp[s] = i;
inv[i] = s;
}
memset(graph, false, sizeof(bool) * 16 * 16);
for (int i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
graph[mp[x]][mp[y]] = graph[mp[y]][mp[x]] = true;
}
for (int i = 0; i < (1 << n); i++) {
bool ok = true;
for (int j = 0; j < n; j++)
for (int k = j + 1; k < n; k++)
if ((1 & (i >> j)) && (1 & (i >> k)))
if (graph[j][k]) ok = false;
if (ok) {
int cnt = 0;
vector<string> tmp;
for (int j = 0; j < n; j++)
if (1 & (i >> j)) {
++cnt;
tmp.push_back(inv[j]);
}
if (cnt > res) {
res = cnt;
ans = tmp;
}
}
}
sort(ans.begin(), ans.end());
cout << res << endl;
for (int i = 0; i < res; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e6 + 10;
map<string, int> ms;
vector<string> vs;
int a[N];
int flag[20][20];
void init() {
a[0] = 0;
for (int i = 1; i < N; i++) {
a[i] = (i & 1) + a[i >> 1];
}
}
int main() {
init();
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
vs.push_back(str);
}
sort(vs.begin(), vs.end());
for (int i = 0; i < n; i++) {
ms[vs[i]] = i;
}
while (m--) {
string s1, s2;
cin >> s1 >> s2;
int x = ms[s1], y = ms[s2];
flag[x][y] = flag[y][x] = 1;
}
pair<int, int> ans = {0, 0};
for (int o = 0; o < (1 << n); o++) {
int f = 1;
for (int i = 0; i < n; i++) {
if (o >> i & 1) continue;
for (int j = 0; j < n; j++) {
if (o >> j & 1) continue;
if (flag[i][j]) f = 0;
}
}
if (f) ans = max(ans, {n - a[o], o});
}
cout << ans.first << endl;
int o = ans.second;
for (int i = 0; i < n; i++) {
if (o >> i & 1) continue;
cout << vs[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int e[20][20];
char c[20][20];
int rd() {
char t[20];
scanf("%s", t);
for (int i = 0; i < n; i++)
if (strcmp(c[i], t) == 0) return i;
}
void input() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) e[i][j] = 1;
for (int i = 0; i < n; i++) scanf("%s", c[i]);
for (int i = 0; i < m; i++) {
int x = rd(), y = rd();
e[x][y] = e[y][x] = 0;
}
}
int a[20];
int ans[20], ansn = 0;
void dfs(int id, int an) {
if (id == n) {
if (ansn < an) {
for (int i = 0; i < an; i++) ans[i] = a[i];
ansn = an;
}
return;
}
dfs(id + 1, an);
for (int i = 0; i < an; i++)
if (e[a[i]][id] == 0) return;
a[an] = id;
dfs(id + 1, an + 1);
}
bool cmp(int x, int y) { return strcmp(c[x], c[y]) < 0; }
void solve() {
dfs(0, 0);
sort(ans, ans + ansn, cmp);
printf("%d\n", ansn);
for (int i = 0; i < ansn; i++) printf("%s\n", c[ans[i]]);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000;
const int MAX = 17;
map<string, int> id;
map<int, string> unid;
vector<string> answer;
bool check[MAX][MAX];
vector<int> now;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string name;
cin >> name;
id[name] = i;
unid[i] = name;
}
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
check[id[a]][id[b]] = true;
check[id[b]][id[a]] = true;
}
int ans = -1;
int ind;
for (int i = 0; i < (1 << n); i++) {
int tmp = 0;
int cur = i;
while (cur != 0) {
if (cur % 2 == 1) tmp++;
now.push_back(cur % 2);
cur /= 2;
}
while (now.size() != n) {
now.push_back(0);
}
reverse(now.begin(), now.end());
bool mark = true;
for (int k = 0; k < now.size(); k++) {
for (int j = 0; j < now.size(); j++) {
if (now[k] == 1 and now[j] == 1 and check[k][j] == true) {
mark = false;
break;
}
}
if (mark == false) {
break;
}
}
if (mark == true) {
if (ans < tmp) ind = i;
ans = max(ans, tmp);
}
now.clear();
}
cout << ans << endl;
while (ind != 0) {
now.push_back(ind % 2);
ind /= 2;
}
while (now.size() != n) now.push_back(0);
reverse(now.begin(), now.end());
for (int i = 0; i < now.size(); i++) {
if (now[i] == 1) {
answer.push_back(unid[i]);
}
}
sort(answer.begin(), answer.end());
for (int i = 0; i < answer.size(); i++) cout << answer[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, res, x, y;
bool f;
map<string, int> M;
char str[11], A[17][11];
bool B[17][17];
vector<string> V;
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", A[i]);
M[A[i]] = i;
}
for (i = 0; i < m; i++) {
scanf("%s", str);
x = M[str];
scanf("%s", str);
y = M[str];
B[x][y] = B[y][x] = 1;
}
for (i = 0; i < 1 << n; i++) {
f = 1;
for (j = 0; j < n; j++)
if (i & 1 << j)
for (k = j + 1; k < n; k++)
if (i & 1 << k && B[j][k]) f = 0;
if (f && __builtin_popcount(res) < __builtin_popcount(i)) res = i;
}
printf("%d\n", __builtin_popcount(res));
for (i = 0; i < n; i++)
if (res & 1 << i) V.push_back(A[i]);
sort(V.begin(), V.end());
for (i = 0; i < V.size(); i++) printf("%s\n", V[i].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> candidates;
for (int i = 0; i < n; i++) {
string s1;
cin >> s1;
candidates.push_back(s1);
}
vector<pair<string, string>> odiados;
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
pair<string, string> x = make_pair(a, b);
odiados.push_back(x);
}
vector<pair<int, int>> cont_pos;
vector<vector<string>> posib;
int pos = 0;
for (int mask = (1 << n) - 1; mask >= 0; mask--) {
bool flag = false;
int cont = 0;
vector<string> provisional;
for (int bit = 0; bit < n; bit++) {
if ((mask >> bit) & 1) {
provisional.push_back(candidates[bit]);
cont++;
}
}
for (int i = 0; i < m; i++) {
if (find(provisional.begin(), provisional.end(), odiados[i].first) !=
provisional.end() &&
find(provisional.begin(), provisional.end(), odiados[i].second) !=
provisional.end()) {
flag = true;
}
}
if (flag)
continue;
else {
sort(provisional.begin(), provisional.end());
pair<int, int> w = make_pair(cont, pos);
cont_pos.push_back(w);
posib.push_back(provisional);
pos++;
}
}
sort(cont_pos.begin(), cont_pos.end());
reverse(cont_pos.begin(), cont_pos.end());
cout << cont_pos[0].first << endl;
for (auto elm : posib[cont_pos[0].second]) cout << elm << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[20][15];
bool road[20][20];
int dp[100000];
char shuchu[20][15];
int comp(const void *_a, const void *_b) {
char *a = (char *)_a;
char *b = (char *)_b;
return strcmp(a, b);
}
int jisuan(int x) {
int queue[25];
int cnt = 1;
int step = 1;
while (x) {
if (x & 1) {
queue[cnt++] = step;
}
step++;
x >>= 1;
}
int i, j;
int flag = 0;
for (i = 1; i < cnt; i++) {
for (j = 1; j < cnt; j++) {
if (i == j) continue;
if (road[queue[i]][queue[j]]) {
flag = 1;
break;
}
}
}
if (flag)
return -1;
else
return cnt - 1;
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
memset(road, false, sizeof(road));
int i;
for (i = 1; i <= n; i++) {
scanf("%s", s[i]);
}
char s1[15], s2[15];
int j;
int k;
int l;
for (j = 1; j <= m; j++) {
scanf("%s%s", s1, s2);
for (k = 1; k <= n; k++) {
if (strcmp(s1, s[k]) == 0) break;
}
for (l = 1; l <= n; l++) {
if (strcmp(s2, s[l]) == 0) break;
}
road[k][l] = road[l][k] = true;
}
int max = 0;
int maxnum = 0;
for (i = 0; i < (1 << n); i++) {
int q = jisuan(i);
if (q > max) {
max = q;
maxnum = i;
}
}
int bu = 1;
printf("%d\n", max);
int ll = 0;
while (maxnum) {
if (maxnum & 1) {
strcpy(shuchu[ll++], s[bu]);
}
bu++;
maxnum >>= 1;
}
qsort(shuchu, max, sizeof(shuchu[0]), comp);
for (i = 0; i < max; i++) {
printf("%s\n", shuchu[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> ans, name;
vector<pair<int, int> > cannot;
int n, m, i, j, num1, num2, mask, x, p;
string s1, s2;
inline bool settedbit(int _mask, int _numbit) {
return (((_mask & (1 << _numbit))) != 0);
}
int main() {
cin >> n >> m;
name.resize(n);
for (i = 0; i < n; i++) cin >> name[i];
cannot.clear();
for (i = 0; i < m; i++) {
cin >> s1 >> s2;
num1 = num2 = -1;
for (j = 0; j < n; j++) {
if (s1 == name[j]) num1 = j;
if (s2 == name[j]) num2 = j;
}
cannot.push_back(make_pair(num1, num2));
}
for (mask = 0; mask < (1 << n); ++mask) {
char flag = true;
for (i = 0; i < m; i++)
if (settedbit(mask, cannot[i].first) &&
settedbit(mask, cannot[i].second)) {
flag = false;
break;
}
if (flag) {
x = 0;
for (p = mask; p > 0; x += (p & 1), p >>= 1)
;
if (x > ans.size()) {
ans.clear();
for (p = 0; p < n; p++)
if (settedbit(mask, p)) ans.push_back(name[p]);
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
int main() {
int n, m;
int graph[N + 1][N + 1];
string volunteers[N + 1];
map<string, int> rel;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
graph[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
string name;
cin >> name;
volunteers[i] = name;
rel[name] = i;
}
for (int i = 0; i < m; i++) {
string f, s;
cin >> f >> s;
graph[rel[f]][rel[s]] = graph[rel[s]][rel[f]] = 1;
}
int combination = 0, match = 0;
for (int mask = 0; mask < (1 << n); mask++) {
bool notPair = false;
int it = 0;
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) {
for (int j = 0; j < n; j++) {
if (mask & (1 << j)) {
if (graph[i][j]) {
notPair = true;
}
}
it++;
}
}
}
if (!notPair && it > match) {
combination = mask;
match = it;
}
}
vector<string> group;
for (int i = 0; i < n; i++) {
if (combination & (1 << i)) {
group.push_back(volunteers[i]);
}
}
sort(group.begin(), group.end());
cout << group.size() << endl;
for (int i = 0; i < group.size(); i++) {
cout << group.at(i) << endl;
}
}
|
#include <bits/stdc++.h>
char name[16][13], *nx[16];
bool map[16][16], pick[17];
int n, m, ma, tm, p;
inline int getid(char *na) {
int i;
for (i = 0; i < n; ++i) {
if (!strcmp(na, name[i])) return i;
}
}
int cal(int st) {
int i, j, tn = 0;
for (i = 0; i < n; ++i) {
if (st & 1)
pick[i] = 1, ++tn;
else
pick[i] = 0;
st = st >> 1;
}
if (tn < ma) return -1;
for (i = 0; i < n; ++i) {
if (!pick[i]) continue;
for (j = i + 1; j < n; ++j) {
if (pick[j] && map[i][j]) return -1;
}
}
return tn;
}
int cmp(const void *a, const void *b) {
return strcmp(*((char **)a), *((char **)b));
}
int main() {
int i, j, ai, bi, n2;
char a[13], b[13];
scanf("%d%d", &n, &m);
for (n2 = 1, i = 0; i < n; ++i) n2 *= 2;
for (i = 0; i < n; ++i) scanf("%s", name[i]);
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) map[i][j] = 0;
}
for (i = 0; i < m; ++i) {
scanf("%s%s", a, b);
ai = getid(a);
bi = getid(b);
map[ai][bi] = 1;
map[bi][ai] = 1;
}
p = 0;
ma = 0;
for (i = 1; i < n2; ++i) {
tm = cal(i);
if (ma < tm) {
ma = tm;
p = i;
}
}
for (i = 0; i < n; ++i) {
if (p & 1)
pick[i] = 1;
else
pick[i] = 0;
p = p >> 1;
}
for (i = 0, j = 0; i < n; ++i) {
if (pick[i]) nx[j++] = name[i];
}
qsort(nx, j, sizeof(char *), cmp);
printf("%d\n", ma);
for (i = 0; i < ma; ++i) printf("%s\n", nx[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
vector<string> names(n);
for (auto& name : names) cin >> name;
map<pair<string, string>, bool> edges;
while (m--) {
string a, b;
cin >> a >> b;
edges[{a, b}] = true;
edges[{b, a}] = true;
}
vector<string> answers;
for (int i = 0; i < (1 << n); ++i) {
if (__builtin_popcount(i) < answers.size()) continue;
vector<string> current;
for (int j = 0; j < n; ++j)
if (i & (1 << j)) current.push_back(names[j]);
bool works = true;
for (int j = 0; j < current.size(); ++j)
for (int k = j + 1; k < current.size(); ++k)
if (edges.count({current[j], current[k]})) works = false;
if (works) answers = current;
}
sort(answers.begin(), answers.end());
cout << answers.size() << '\n';
for (auto& answer : answers) cout << answer << '\n';
}
|
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::map<std::string, int> names;
int n;
int m;
std::cin >> n >> m;
int h = n;
unsigned i = 1 << n;
while (n--) {
std::string name;
std::cin >> name;
names.emplace(std::move(name), n);
}
std::vector<unsigned> forbidden(m);
for (auto&& mask : forbidden) {
std::string a;
std::string b;
std::cin >> a >> b;
mask = 1 << names.find(a)->second | 1 << names.find(b)->second;
}
int best_h = 0;
unsigned best_mask = 0;
while (i--) {
if (h > best_h) {
auto it =
std::find_if(forbidden.begin(), forbidden.end(), [&](unsigned f) {
f &= i;
return f & (f - 1);
});
if (it == forbidden.end()) {
best_h = h;
best_mask = i;
}
}
unsigned j = i & ~(i - 1);
while (j >>= 1) {
h++;
}
h--;
}
std::cout << best_h << '\n';
for (const auto& p : names) {
if (best_mask & 1 << p.second) std::cout << p.first << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
vector<vector<int> > v(n);
for (int i = 0; i < n; ++i) cin >> s[i];
sort(s.begin(), s.end());
for (int i = 0; i < m; ++i) {
string x, y;
cin >> x >> y;
int xx, yy;
for (int i = 0; i < n; ++i)
if (s[i] == x)
xx = i;
else if (s[i] == y)
yy = i;
v[xx].push_back(yy);
v[yy].push_back(xx);
}
int b[20];
fill(b, b + 20, 0);
int res = 1;
vector<string> ress(1, s[0]);
while (!b[n]) {
++b[0];
for (int i = 0; i < n; ++i)
if (b[i] == 2) {
++b[i + 1];
b[i] = 0;
}
bool ok = true;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (b[i] && b[j]) {
for (int ii = 0; ii < v[i].size(); ++ii)
if (v[i][ii] == j) {
ok = false;
goto l;
}
}
l:;
int k = 0;
vector<string> ss;
for (int i = 0; i < n; ++i)
if (b[i]) ++k, ss.push_back(s[i]);
if (ok && res < k) res = k, ress = ss;
}
cout << res << endl;
for (int i = 0; i < ress.size(); ++i) cout << ress[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, never[17], ans;
string name[16];
vector<int> notgood[17];
int count(int i) {
int res = 0;
while (i) {
res += i & 1;
i >>= 1;
}
return res;
}
int main() {
unordered_map<string, int> con;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> name[i], con[name[i]] = i;
for (string a, b; m--;) {
cin >> a >> b;
int i = con[a], j = con[b];
notgood[i].push_back(j);
notgood[j].push_back(i);
}
for (int i = 0, ok; i < (1 << n); ++i) {
for (int j = 0; j < n; ++j)
if (i & (1 << j))
for (int &k : notgood[j]) never[k] = i + 1;
ok = true;
for (int j = 0; j < n and ok; ++j)
if ((i & (1 << j)) and never[j] == i + 1) ok = false;
if (ok and count(i) > count(ans)) ans = i;
}
m = count(ans);
cout << m << '\n';
for (int j = 0, k = 0; j < n; ++j)
if (ans & (1 << j)) name[k++] = name[j];
sort(name, name + m);
for (int i = 0; i < m; ++i) cout << name[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, vector<string> > graph;
bool valid(set<string>& t) {
for (auto i = t.begin(); i != t.end(); i++) {
for (auto k : graph[*i]) {
if (t.find(k) != t.end()) {
return false;
}
}
}
return true;
}
void solve() {
long long int n, m;
cin >> n >> m;
vector<string> players(n);
for (long long int i = 0; i < n; i++) {
cin >> players[i];
}
for (long long int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
set<string> ans;
for (long long int i = 1; i < (1 << (n + 1)); i++) {
set<string> tmp;
if (__builtin_popcount(i) >= ans.size()) {
for (long long int j = 0; j <= log2(i); j++) {
if (i & (1 << j)) {
tmp.insert(players[min(n - 1, j)]);
}
}
if (ans.size() < tmp.size() && valid(tmp)) {
ans = tmp;
}
}
tmp.clear();
}
cout << ans.size() << '\n';
for (string s : ans) {
cout << s << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
while (T--) {
solve();
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> p;
string str[16];
int g[16][16] = {};
int countbit(int n) {
int k = 0;
while (n > 0) {
k += n % 2;
n /= 2;
}
return k;
}
int main(void) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> str[i];
p[str[i]] = i;
}
for (int i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
g[p[x]][p[y]] = g[p[y]][p[x]] = 1;
}
int ans = 0;
for (int state = 0; state < (1 << n); state++) {
if (countbit(ans) >= countbit(state)) continue;
int flag = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if ((state & (1 << i)) && (state & (1 << j)) && g[i][j]) flag = 1;
if (!flag) ans = state;
}
vector<string> w;
for (int i = 0; i < n; i++)
if ((ans & (1 << i))) w.push_back(str[i]);
sort(w.begin(), w.end());
cout << w.size() << endl;
for (int i = 0; i < (int)w.size(); i++) cout << w[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, T;
map<string, int> mp;
set<string> s;
set<string>::iterator it;
char str[22];
char ss[22][22];
int tb[20][20];
int Mc;
int num[20];
void gen(int idx) {
if (idx == N) {
int i, j, k;
for (i = 1; i <= N; i++)
for (j = i + 1; j <= N; j++)
if (num[i] && num[j] && tb[i][j]) return;
k = 0;
for (i = 1; i <= N; i++)
if (num[i]) k++;
if (k > Mc) {
Mc = k;
s.clear();
for (i = 1; i <= N; i++)
if (num[i]) s.insert(ss[i]);
}
return;
}
num[idx + 1] = 1;
gen(idx + 1);
num[idx + 1] = 0;
gen(idx + 1);
}
int main() {
int i, j, k;
scanf("%d%d", &N, &M);
for (i = 1; i <= N; i++) {
scanf("%s", ss[i]);
mp[ss[i]] = i;
}
int x, y;
for (i = 1; i <= M; i++) {
scanf("%s", str);
x = mp[str];
scanf("%s", str);
y = mp[str];
tb[x][y] = 1;
tb[y][x] = 1;
}
gen(0);
printf("%d\n", Mc);
for (it = s.begin(); it != s.end(); it++) cout << (*it) << endl;
scanf(" ");
}
|
#include <bits/stdc++.h>
using namespace std;
bool enemies[16][16];
bool check(int mask, int namesNumber) {
for (int i = 0; i < namesNumber; i++) {
if ((mask & (1 << i)) == 0) continue;
for (int j = 0; j < namesNumber; j++) {
if (i == j) continue;
if ((mask & (1 << j)) == 0) continue;
if (enemies[i][j] || enemies[j][i]) return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int namesNumber, enemiesNumber;
string name;
cin >> namesNumber >> enemiesNumber;
vector<string> people;
map<string, int> indexes;
for (int i = 0; i < namesNumber; i++) {
cin >> name;
people.push_back(name);
indexes[name] = i;
}
string firstEnemy, secondEnemy;
while (enemiesNumber--) {
cin >> firstEnemy >> secondEnemy;
enemies[indexes[firstEnemy]][indexes[secondEnemy]] = true;
enemies[indexes[secondEnemy]][indexes[firstEnemy]] = true;
}
vector<string> dreamTeam;
int numberOfPeopleForMask;
for (int mask = ((1 << namesNumber) - 1); mask > 0; mask--) {
vector<string> peopleForMask;
numberOfPeopleForMask = 0;
if (check(mask, namesNumber)) {
for (int bit = 0; bit < namesNumber; bit++) {
if ((1 << bit) & mask) {
peopleForMask.push_back(people[bit]);
numberOfPeopleForMask++;
}
}
}
if (numberOfPeopleForMask > dreamTeam.size()) {
dreamTeam = peopleForMask;
}
}
cout << dreamTeam.size() << endl;
sort(dreamTeam.begin(), dreamTeam.end());
for (string personTmp : dreamTeam) cout << personTmp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s[n];
map<string, int> mp;
map<int, string> rvmp;
for (int i = 0; i < n; i++) {
cin >> s[i];
mp[s[i]] = i;
rvmp[i] = s[i];
}
map<pair<string, string>, int> t;
for (int i = 0; i < m; i++) {
string aa, bb;
cin >> aa >> bb;
t[{aa, bb}] = 1;
t[{bb, aa}] = 1;
}
vector<string> ans, temp1;
int temp = 0;
for (long int i = 1; i <= pow(2, n); i++) {
int cnt = 0, j = i;
while (j > 0) {
if (j % 2 == 1) {
temp1.push_back(rvmp[cnt]);
}
cnt++;
j /= 2;
}
cnt = temp1.size();
bool pp = 0;
for (long int ij = 0; ij < cnt; ij++) {
for (long int k = ij + 1; k < cnt; k++) {
if (t[{temp1[ij], temp1[k]}]) pp = 1;
}
}
if (pp == 0) {
if (cnt > temp) {
temp = cnt;
ans.clear();
for (long int k = 0; k < cnt; k++) {
ans.push_back(temp1[k]);
}
}
}
temp1.clear();
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool enemies[16][16];
bool check(int mask, int namesNumber) {
for (int i = 0; i < namesNumber; i++) {
if ((mask & (1 << i)) == 0) continue;
for (int j = 0; j < namesNumber; j++) {
if (i == j) continue;
if ((mask & (1 << j)) == 0) continue;
if (enemies[i][j] || enemies[j][i]) return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int namesNumber, enemiesNumber;
string name;
cin >> namesNumber >> enemiesNumber;
vector<string> people;
map<string, int> indexes;
for (int i = 0; i < namesNumber; i++) {
cin >> name;
people.push_back(name);
indexes[name] = i;
}
string firstEnemy, secondEnemy;
while (enemiesNumber--) {
cin >> firstEnemy >> secondEnemy;
enemies[indexes[firstEnemy]][indexes[secondEnemy]] = true;
enemies[indexes[secondEnemy]][indexes[firstEnemy]] = true;
}
vector<string> dreamTeam;
int numberOfPeopleForMask;
for (int mask = ((1 << namesNumber) - 1); mask > 0; mask--) {
vector<string> peopleForMask;
numberOfPeopleForMask = 0;
if (check(mask, namesNumber)) {
for (int bit = 0; bit < namesNumber; bit++) {
if ((1 << bit) & mask) {
peopleForMask.push_back(people[bit]);
numberOfPeopleForMask++;
}
}
}
if (numberOfPeopleForMask > dreamTeam.size()) {
dreamTeam = peopleForMask;
}
}
sort(dreamTeam.begin(), dreamTeam.end());
cout << dreamTeam.size() << endl;
for (int i = 0; i < dreamTeam.size(); i++) {
cout << dreamTeam[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool E[20][20];
int n, m;
bool dp[70000];
bool check(int key) {
int msk = 1 << n;
int cnt = n, e1;
while (!(msk & key)) {
cnt--;
msk >>= 1;
}
e1 = cnt;
key = (~msk) & key;
if (!dp[key]) return false;
while (msk) {
if (msk & key) {
if (E[cnt][e1]) return false;
}
cnt--;
msk >>= 1;
}
return true;
}
int NUM(int key) {
int cnt = 0;
while (key) {
cnt++;
key = key & (key - 1);
}
return cnt;
}
int main() {
int i, j = 0, key;
map<string, int> M;
map<int, string> L;
string str, str2;
int mx = 0, msk;
vector<string> V;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> str;
M[str] = i;
L[i] = str;
dp[1 << i] = true;
}
for (i = 0; i < m; i++) {
cin >> str >> str2;
E[M[str]][M[str2]] = E[M[str2]][M[str]] = true;
}
j = 1 << n;
for (i = 1; i < j; i++) {
if (!dp[i]) {
dp[i] = check(i);
}
}
for (i = 1; i < j; i++) {
if (dp[i]) {
m = NUM(i);
if (mx < m) {
mx = m;
key = i;
}
}
}
msk = 1 << n;
j = n;
cout << mx << endl;
while (msk) {
if (msk & key) V.push_back(L[j]);
j--;
msk >>= 1;
}
sort(V.begin(), V.end());
for (i = 0; i < V.size(); i++) cout << V[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int g[16][16];
vector<string> vs;
map<string, int> m;
int n, mm;
memset(g, 0, sizeof(g));
scanf("%d %d", &n, &mm);
for (int i = 0; i < n; i++) {
char name[20];
scanf("%s", name);
m.insert(make_pair(name, i));
vs.push_back(name);
}
for (int i = 0; i < mm; i++) {
char name1[20], name2[20];
scanf("%s %s", name1, name2);
int a = m[name1], b = m[name2];
g[a][b] = 1;
}
int res = 0;
vector<int> res_v;
for (int i = 0; i < 1 << n; i++) {
int cnt = 0;
vector<int> v;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) {
cnt++;
v.push_back(j);
}
bool flag = true;
for (int j = 0; j < v.size(); j++)
for (int k = 0; k < v.size(); k++)
if (g[v[j]][v[k]] == 1) flag = false;
if (flag && cnt > res) {
res = cnt;
res_v = v;
}
}
vector<string> rv;
for (int i = 0; i < res_v.size(); i++) rv.push_back(vs[res_v[i]]);
sort(rv.begin(), rv.end());
printf("%d\n", res);
for (int i = 0; i < rv.size(); i++) printf("%s\n", rv[i].c_str());
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
long long int modularExponentiation(long long int x, long long int n,
long long int M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modularExponentiation((x * x) % M, n / 2, M);
else
return (x * modularExponentiation((x * x) % M, (n - 1) / 2, M)) % M;
}
long long int CeilIndex(std::vector<long long int>& v, long long int l,
long long int r, long long int key) {
while (r - l > 1) {
long long int m = l + (r - l) / 2;
if (v[m] > key)
r = m;
else
l = m;
}
return r;
}
long long int LongestIncreasingSubsequenceLength(
std::vector<long long int>& v) {
if (v.size() == 0) return 0;
std::vector<long long int> tail(v.size(), 0);
long long int length = 1;
tail[0] = v[0];
for (size_t i = 1; i < v.size(); i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] >= tail[length - 1])
tail[length++] = v[i];
else
tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i];
}
return length;
}
bool check(int m, vector<pair<int, int>> v) {
int f = 0;
for (int i = 0; i < v.size(); i++) {
int x = v[i].first;
int y = v[i].second;
if (x > m && y > m) {
f = 1;
break;
}
}
if (f == 1)
return false;
else
return true;
}
long long int subCount(long long int arr[], long long int n, long long int k) {
long long int mod[k];
memset(mod, 0, sizeof(mod));
long long int cumSum = 0;
for (long long int i = 0; i < n; i++) {
cumSum += arr[i];
mod[((cumSum % k) + k) % k]++;
}
long long int result = 0;
for (long long int i = 0; i < k; i++)
if (mod[i] > 1) result += (mod[i] * (mod[i] - 1)) / 2;
result += mod[0];
return result;
}
bool isPerfectSquare(long double x) {
if (x >= 0) {
long double sr = sqrt(x);
return (sr * sr == x);
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
cin >> n >> m;
vector<string> v(16);
set<string> ans;
for (long long int i = 0; i < n; i++) cin >> v[i];
vector<pair<string, string>> vp(120);
for (long long int i = 0; i < m; i++) cin >> vp[i].first >> vp[i].second;
for (long long int i = 0; i < (1 << n); i++) {
set<string> s;
long long int valid = 1;
for (long long int j = 0; j < n; j++) {
if ((i >> j) & 1) s.insert(v[j]);
}
for (long long int k = 0; k < m; k++) {
if (s.find(vp[k].first) != s.end() && s.find(vp[k].second) != s.end())
valid = 0;
}
if (valid) {
long long int size = s.size();
if (s.size() > ans.size()) ans = s;
}
}
cout << ans.size() << endl;
for (auto it = ans.begin(); it != ans.end(); it++) cout << *it << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int oo = 0x3f3f3f3f;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T gcd(T a, T b) {
T c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
template <class T>
inline T mabs(T a) {
if (a < 0)
return -a;
else
return a;
}
typedef vector<int> VI;
typedef vector<VI> VII;
typedef vector<string> VS;
const int N = (int)21;
const int MOD = (int)1e9 + 7;
int g[N][N];
inline int solve(int testnum) {
int n, k;
cin >> n >> k;
map<string, int> names;
names.clear();
map<int, string> idx2name;
idx2name.clear();
for (int i = (0); i < int(n); i++) {
string s;
cin >> s;
names[s] = i;
idx2name[i] = s;
}
for (int i = (0); i < int(n); i++)
for (int j = (0); j < int(n); j++) g[i][j] = 1;
for (int i = (0); i < int(k); i++) {
string a, b;
cin >> a >> b;
int ia = names[a];
int ib = names[b];
g[ia][ib] = 0;
}
int best = 0;
for (int mask = (0); mask < int((1 << (n))); mask++) {
int f = 1;
for (int i = (0); i < int(n); i++) {
if ((mask & (1 << (i))) > 0) {
for (int j = (0); j < int(n); j++)
if ((mask & (1 << (j))) > 0) {
if (g[i][j] == 0) {
f = 0;
}
}
}
}
if (!f || !mask) continue;
if (countbit(mask) > countbit(best)) {
best = mask;
}
}
VS ret;
ret.clear();
for (int b = (0); b < int(n); b++)
if ((best & (1 << (b))) > 0) {
ret.push_back(idx2name[b]);
}
sort((ret).begin(), (ret).end());
printf("%d\n", ret.size());
for (auto &j : ret) printf("%s\n", j.c_str());
return 0;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
int t = 1;
if (argc > 1) t = atoi(argv[1]);
for (int _t = (1); _t < int(t + 1); _t++) {
int ret = ::solve(_t);
if (ret == -1) {
cerr << "Failed test #" << _t << endl;
break;
}
cerr << "Solved test #" << _t << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
string a[20];
map<long long int, string> mp;
set<pair<string, string>> s;
bool possible(string bin) {
long long int f = 0;
long long int i, j, n = bin.size();
vector<string> v1;
long long int c = 0;
for (i = n - 1; i >= 0; i--) {
if (mp.find(c) != mp.end()) {
if (bin[i] == '1') v1.push_back(mp[c]);
} else
break;
c++;
}
for (i = 0; i < v1.size(); i++) {
for (j = i + 1; j < v1.size(); j++) {
if (v1[i] < v1[j]) {
if (s.find({v1[i], v1[j]}) != s.end()) {
return false;
}
} else {
if (s.find({v1[j], v1[i]}) != s.end()) {
return false;
}
}
}
}
return true;
}
void solve() {
long long int i, j, c, x, y;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a[i];
mp[i] = a[i];
}
for (i = 0; i < m; i++) {
string p, q;
cin >> p >> q;
if (p < q)
s.insert({p, q});
else
s.insert({q, p});
}
set<string> ans;
long long int maxi = 0;
for (i = 0; i < pow(2, n); i++) {
x = i;
string bin = "";
for (j = 31; j >= 0; j--) {
long long int k = x >> j;
if (k & 1)
bin.push_back('1');
else
bin.push_back('0');
}
if (possible(bin)) {
long long int cnt = 0;
set<string> tmp;
for (j = 0; j < bin.size(); j++) {
if (bin[j] == '1') cnt++;
}
if (cnt > maxi) {
maxi = cnt;
long long int c = 0;
for (j = bin.size() - 1; j >= 0; j--) {
if (mp.find(c) != mp.end()) {
if (bin[j] == '1') tmp.insert(mp[c]);
} else
break;
c++;
}
ans = tmp;
}
}
}
cout << ans.size() << "\n";
for (auto it = ans.begin(); it != ans.end(); it++) cout << *it << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) solve();
cerr << "\nTime elapsed: " << setprecision(5)
<< 1000.0 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string volunteers[1000];
map<string, int> volunteersId;
vector<int> ids;
vector<int> temp;
int n, m;
cin >> n;
cin >> m;
int uselessPairs[1000][1000];
for (int i = 0; i < n; i++) {
cin >> volunteers[i];
volunteersId.insert(std::make_pair(volunteers[i], i));
}
for (int i = 0; i < m; i++) {
string firstVolunteer;
string secondVolunteer;
cin >> firstVolunteer;
cin >> secondVolunteer;
uselessPairs[volunteersId.at(firstVolunteer)]
[volunteersId.at(secondVolunteer)] = 1;
uselessPairs[volunteersId.at(secondVolunteer)]
[volunteersId.at(firstVolunteer)] = 1;
}
int foundedMask = -1;
int activeBits = -1;
for (int i = 0; i < 1 << n; i++) {
bool foundUseless = false;
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0) continue;
for (int k = 0; k < n; k++) {
if (j == k || ((i & (1 << k)) == 0)) continue;
if (uselessPairs[j][k]) {
foundUseless = true;
break;
}
}
}
if (!foundUseless) {
if (__builtin_popcount(i) > activeBits) {
activeBits = __builtin_popcount(i);
foundedMask = i;
}
}
}
vector<string> temp2;
for (int i = 0; i < n; i++) {
if (foundedMask & (1 << i)) {
temp2.push_back(volunteers[i]);
}
}
sort(temp2.begin(), temp2.end());
cout << activeBits << endl;
for (int i = 0; i < temp2.size(); i++) {
cout << temp2.at(i) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long n, q, max_size = 0;
cin >> n >> q;
string arr[n];
vector<string> ans_v;
for (int i = 0; i < n; ++i) cin >> arr[i];
map<pair<string, string>, bool> mp;
for (int i = 0; i < q; ++i) {
string str1, str2;
cin >> str1 >> str2;
mp[make_pair(str1, str2)] = true;
}
for (int mask = 0; mask < (1 << n); ++mask) {
vector<string> ans;
for (int i = 0; i < n; ++i) {
if (mask & (1 << i)) {
ans.push_back(arr[i]);
}
}
bool suit = true;
for (int j = 0; j < ans.size(); ++j) {
for (int k = 0; k < ans.size(); ++k) {
if (mp[make_pair(ans[j], ans[k])] == true) {
suit = false;
break;
}
}
}
if (suit) {
if (max_size < ans.size()) {
max_size = ans.size();
ans_v = ans;
}
}
}
cout << max_size << endl;
sort(ans_v.begin(), ans_v.end());
for (int i = 0; i < max_size; ++i) {
cout << ans_v[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
int edge[((1) << (N))];
int cnt[((1) << (N))];
int main() {
int n, m;
cin >> n >> m;
map<string, int> mem;
vector<string> all(n);
for (int i = 0; i < (n); ++i) {
string name;
cin >> name;
mem[name] = i;
all[i] = name;
}
for (int i = 0; i < (m); ++i) {
string a, b;
cin >> a >> b;
edge[((1) << (mem[a]))] |= ((1) << (mem[b]));
edge[((1) << (mem[b]))] |= ((1) << (mem[a]));
}
int ans = 0, best = 0;
for (typeof(1) mk = 1; mk < ((1) << (n)); ++mk) {
edge[mk] = edge[mk ^ ((mk) & ((mk) ^ ((mk)-1)))] |
edge[((mk) & ((mk) ^ ((mk)-1)))];
cnt[mk] = cnt[mk ^ ((mk) & ((mk) ^ ((mk)-1)))] + 1;
;
;
if (0 == (edge[mk] & mk) && ans < cnt[mk]) {
best = mk;
ans = cnt[mk];
;
;
}
}
vector<string> team;
for (int i = 0; i < (n); ++i)
if (((1) << (i)) & best) team.push_back(all[i]);
sort((team).begin(), (team).end());
cout << ans << endl;
for (int i = 0; i < (((int)(team).size())); ++i) cout << team[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> p;
string str[16];
int g[16][16] = {};
int cnt_bit(int a) {
int ans = 0;
while (a > 0) {
ans += a % 2;
a /= 2;
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> str[i];
p[str[i]] = i;
}
for (int i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
g[p[x]][p[y]] = 1;
g[p[y]][p[x]] = 1;
}
int ans = 0;
for (int state = 0; state < (1 << n); state++) {
if (cnt_bit(ans) >= cnt_bit(state)) continue;
bool flag = false;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((state & (1 << i)) && (state & (1 << j)) && g[i][j]) flag = true;
}
}
if (!flag) ans = state;
}
vector<string> w;
for (int i = 0; i < n; i++)
if (ans & (1 << i)) w.push_back(str[i]);
sort(w.begin(), w.end());
cout << w.size() << "\n";
for (int i = 0; i < int(w.size()); i++) cout << w[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string x[17];
vector<vector<int> > y(17);
int n, maxm, ind, r[17][17];
void AllGetOn(int Me, vector<int> chosen, bool b) {
if (b) chosen.push_back(Me);
if (Me >= n) {
y.push_back(chosen);
return;
}
b = 0;
for (int i = 0; i < chosen.size(); i++)
if (r[Me + 1][chosen[i]]) b = 1;
if (!b) AllGetOn(Me + 1, chosen, 1);
AllGetOn(Me + 1, chosen, 0);
}
int main() {
int m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x[i];
sort(x + 1, x + n + 1);
for (int i = 0; i < m; i++) {
string y, z;
cin >> y >> z;
int ind1, ind2;
for (int j = 1; j <= n; j++)
if (x[j] == y)
ind1 = j;
else if (x[j] == z)
ind2 = j;
r[ind1][ind2] = r[ind2][ind1] = 1;
}
vector<int> z;
AllGetOn(0, z, 0);
for (int i = 0; i < y.size(); i++)
if (maxm < y[i].size()) {
maxm = y[i].size();
ind = i;
}
cout << y[ind].size() << endl;
;
sort(y[ind].begin(), y[ind].end());
for (int i = 0; i < y[ind].size(); i++) cout << x[y[ind][i]] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void fastscan(int &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
bool comparable(pair<string, int> p1, pair<string, int> p2) {
return p1.second < p2.second;
}
int main() {
int n, mm;
cin >> n >> mm;
string m[n];
pair<string, string> h[mm];
string s, s2;
for (int i = 0; i < n; i++) {
cin >> m[i];
}
for (int i = 0; i < mm; i++) {
cin >> s >> s2;
h[i].first = s;
h[i].second = s2;
}
vector<string> best(0);
for (int i = 1; i < (1 << n); i++) {
vector<string> team;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) team.push_back(m[j]);
bool cont = true;
for (int j = 0; j < mm && cont; j++)
if (find(team.begin(), team.end(), h[j].first) != team.end() &&
find(team.begin(), team.end(), h[j].second) != team.end())
cont = false;
if (cont && best.size() < team.size()) best = team;
}
sort(best.begin(), best.end());
cout << best.size() << endl;
for (int i = 0; i < best.size(); i++) cout << best[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, k;
cin >> n >> m;
vector<string> name(n), store;
for (i = 0; i < n; i++) {
cin >> name[i];
}
map<string, map<string, bool>> M;
for (i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
M[s1][s2] = true;
M[s2][s1] = true;
}
for (i = 0; i < (1 << n); i++) {
vector<string> check;
for (j = 0; j < n; j++) {
if (i & (1 << j)) {
check.push_back(name[j]);
}
}
bool f = true;
for (k = 0; k < check.size(); k++) {
for (j = k + 1; j < check.size(); j++) {
if (M[check[k]][check[j]]) {
f = false;
}
}
}
if (f && check.size() > store.size()) store = check;
}
sort(store.begin(), store.end());
cout << store.size() << endl;
for (i = 0; i < store.size(); i++) {
cout << store[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)(1e9);
const int mod = inf + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
map<string, int> id;
int n, m;
string second, t, b[100];
bool a[100][100];
vector<int> v;
bool was[1 << 17];
bool check(int mask) {
bool ok = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((mask & (1 << j)) && (mask & (1 << i)) && a[i][j]) {
ok = 0;
break;
}
}
if (!ok) break;
}
return ok;
}
int bitcnt(int mask) {
int k = 0;
for (int i = 0; i < n; i++)
if (mask & (1 << i)) k++;
return k;
}
bool cmp(int a, int b) {
int k1 = 0, k2 = 0;
for (int i = 0; i < n; i++) {
if (a & (1 << i)) k1++;
if (b & (1 << i)) k2++;
}
return (k1 <= k2);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> second;
id[second] = i;
b[i] = second;
}
for (int i = 0; i < m; i++) {
cin >> second >> t;
a[id[second]][id[t]] = 1;
a[id[t]][id[second]] = 1;
}
for (int i = 0; i < (1 << n); i++) {
if (check(i)) v.push_back(i);
}
int mask = -1, p = -inf;
for (int i = 0; i < (int)v.size(); i++) {
int k = bitcnt(v[i]);
if (p < k) {
p = k;
mask = v[i];
}
}
set<string> ans;
for (int i = 0; i < n; i++)
if (mask & (1 << i)) ans.insert(b[i]);
printf("%d\n", (int)ans.size());
for (__typeof(ans.begin()) it = ans.begin(); it != ans.end(); it++)
cout << *it << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ansno = 0, no = 0;
string arr[20];
bool conf[20][20];
map<string, int> mp;
vector<string> vec;
vector<string> ans;
bool valid(int indx) {
if (indx == -1) return 1;
for (int i = 0; i < (int)vec.size(); i++)
if (conf[mp[vec[i]]][indx]) return 0;
return 1;
}
void backtrack(int indx_arr) {
if (!valid(indx_arr)) return;
if (indx_arr != -1) vec.push_back(arr[indx_arr]), no++;
if (no > ansno) ansno = no, ans = vec;
for (int i = indx_arr + 1; i < n; i++) backtrack(i);
if (indx_arr != -1) vec.pop_back(), no--;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]] = i;
}
for (int i = 0; i < k; i++) {
string x, y;
cin >> x >> y;
conf[mp[x]][mp[y]] = 1, conf[mp[y]][mp[x]] = 1;
}
backtrack(-1);
cout << ans.size() << "\n";
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16 + 5;
string a[N], x, y;
int n, m, M = -1;
map<string, map<string, int> > mm;
bool vis[N];
void dfs(int deep, int mod) {
if (deep > n + 1) return;
if (deep == n + 1) {
int tot = 0, f = 1;
for (int i = 1; i <= n; ++i) tot += vis[i];
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (vis[i] && vis[j])
if (mm[a[i]][a[j]]) {
f = 0;
break;
}
if (f) {
if (mod) {
int tot = 0;
for (int i = 1; i <= n; ++i) tot += vis[i];
if (tot != M) return;
printf("%d\n", M);
string res[N];
for (int i = 1; i <= 17; ++i) res[i] = "0";
int pos = 1;
for (int i = 1; i <= n; ++i)
if (vis[i]) res[pos++] = a[i];
sort(res + 1, res + pos);
pos = 1;
while (res[pos] != "0") {
cout << res[pos] << endl;
pos++;
}
exit(0);
} else if (mod == 0)
M = max(M, tot);
}
}
vis[deep] = true;
dfs(deep + 1, mod);
vis[deep] = false;
dfs(deep + 1, mod);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
mm[x][y] = mm[y][x] = 1;
}
dfs(1, 0);
dfs(1, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, adj[20][20], dp[20][1 << 17];
string names[20];
bool valid(int idx, int msk) {
for (int i = 0; i < n; ++i)
if ((msk & (1 << i)) && (adj[idx][i])) return 0;
return 1;
}
int solve(int idx, int msk) {
if (idx >= n) return 0;
int& ret = dp[idx][msk];
if (ret != -1) return ret;
ret = solve(idx + 1, msk);
if (valid(idx, msk)) {
ret = max(ret, solve(idx + 1, msk | (1 << idx)) + 1);
}
return ret;
}
void printAns(int idx, int msk) {
if (idx >= n) return;
if (valid(idx, msk) &&
solve(idx, msk) == solve(idx + 1, msk | (1 << idx)) + 1) {
cout << names[idx] << endl;
printAns(idx + 1, msk | (1 << idx));
} else {
printAns(idx + 1, msk);
}
}
int main() {
int m, i;
string s, t;
map<string, int> mp;
cin >> n >> m;
for (i = 0; i < n; ++i) cin >> names[i];
sort(names, names + n);
for (i = 0; i < n; ++i) mp[names[i]] = i;
for (i = 0; i < m; ++i) {
cin >> s >> t;
adj[mp[s]][mp[t]] = 1;
adj[mp[t]][mp[s]] = 1;
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0) << endl;
printAns(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
map<pair<int, string>, string> dp;
vector<string> members;
map<pair<string, string>, bool> hate;
bool valid(string s, int ind) {
for (int i = 0; i < ind; i++)
if (s[i] == '1') {
if (hate.count({members[ind], members[i]}) != 0) return false;
}
return true;
}
string solve(int ind, string team) {
if (ind == n) return team;
if (dp.count({ind, team}) != 0) return dp[{ind, team}];
if (valid(team, ind)) {
string temp = team;
temp[ind] = '1';
string s1 = solve(ind + 1, temp);
string s2 = solve(ind + 1, team);
return (count(s1.begin(), s1.end(), '1') > count(s2.begin(), s2.end(), '1'))
? s1
: s2;
} else
return dp[{ind, team}] = solve(ind + 1, team);
}
int main() {
int h;
cin >> n >> h;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
members.push_back(s);
}
sort(members.begin(), members.end());
for (size_t i = 0; i < h; i++) {
string s1, s2;
cin >> s1 >> s2;
hate[{s1, s2}] = true;
hate[{s2, s1}] = true;
}
string team = "";
for (int i = 0; i < n; i++) team += '0';
string sol = solve(0, team);
cout << count(sol.begin(), sol.end(), '1') << endl;
for (int i = 0; i < sol.size(); i++)
if (sol[i] == '1') cout << members[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000 * 1000 * 1000 + 7;
const double PI = 3.14159265358979323846264;
const pair<long long int, long long int> steps[] = {
{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, -1}, {1, 1}, {-1, -1}, {-1, 1}};
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
void fio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void setUpLocal() {}
const long long int maxn = 20;
long long int n, m;
map<string, long long int> mp;
map<long long int, string> revmp;
long long int gp[maxn][maxn];
vector<long long int> ans;
bool check(vector<long long int> v) {
for (long long int i : v)
for (long long int j : v)
if (gp[i][j]) return false;
return true;
}
bool comp(long long int i, long long int j) { return revmp[i] < revmp[j]; }
void solve() {
cin >> n >> m;
long long int cnt = -1;
long long int _n = n;
while (_n--) {
string s;
cin >> s;
mp[s] = ++cnt;
revmp[cnt] = s;
}
string u, v;
while (m--) {
cin >> u >> v;
gp[mp[u]][mp[v]] = 1;
gp[mp[v]][mp[u]] = 1;
}
for (long long int i = 1; i < (1 << n); i++) {
vector<long long int> v;
for (long long int j = 0; j < n; j++) {
if (((i) & (1 << (j)))) v.push_back(j);
}
if (v.size() > ans.size())
if (check(v)) ans = v;
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end(), comp);
for (long long int i : ans) cout << revmp[i] << '\n';
}
int32_t main() {
fio();
setUpLocal();
return solve(), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char NL = '\n';
long long mod = 1000000007;
void read(vector<long long> &a);
inline void solve() {
long long n, m;
cin >> n >> m;
map<string, long long> st;
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
st[s] = i;
}
vector<pair<long long, long long>> hate(m);
for (long long i = 0; i < m; i++) {
string s, t;
cin >> s >> t;
hate[i] = {st[s], st[t]};
}
long long ans = 0;
vector<string> mxb;
for (long long i = 0; i <= pow(2, n); i++) {
bitset<16> te(i);
bool valid = 1;
for (auto [i, j] : hate) {
if (te[i] == te[j] && te[i] == 1) valid = 0;
}
if (valid) {
if (ans < te.count()) {
mxb.clear();
ans = te.count();
for (long long i = 0; i < 16; i++) {
if (te[i]) {
for (auto [name, val] : st) {
if (val == i) mxb.push_back(name);
}
}
}
}
}
}
cout << ans << NL;
sort(mxb.begin(), mxb.end());
for (string s : mxb) cout << s << NL;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
fflush(stdin);
fflush(stdout);
return 0;
}
void read(vector<long long> &a) {
for (auto &it : a) cin >> it;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
bool g[N][N];
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
map<string, int> a;
map<int, string> b;
string s, t;
for (int i = (0), _b = (n); i < (_b); ++i) {
cin >> s;
a[s] = i;
b[i] = s;
}
for (int i = (0), _b = (n); i < (_b); ++i)
for (int j = (i + 1), _b = (n); j < (_b); ++j) g[i][j] = g[j][i] = true;
for (int i = (0), _b = (m); i < (_b); ++i) {
cin >> s >> t;
int x = a[s];
int y = a[t];
g[x][y] = g[y][x] = false;
}
set<string> ans;
for (int x = 0; x < (1 << n); ++x) {
set<string> tmp;
for (int i = 0; i < n; ++i) {
if ((1 << i) & x) {
tmp.insert(b[i]);
}
}
vector<string> v;
for (typeof((tmp).begin()) it = (tmp).begin(); it != (tmp).end(); it++)
v.push_back(*it);
bool ok = true;
for (int i = (0), _b = (v.size()); i < (_b); ++i)
for (int j = (0), _b = (v.size()); j < (_b); ++j) {
if (i == j) continue;
int x = a[v[i]];
int y = a[v[j]];
if (!g[x][y]) {
ok = false;
break;
}
}
if (ok) {
if (tmp.size() > ans.size()) {
ans.clear();
for (typeof((tmp).begin()) it = (tmp).begin(); it != (tmp).end(); it++)
ans.insert(*it);
}
}
}
cout << ans.size() << endl;
for (typeof((ans).begin()) it = (ans).begin(); it != (ans).end(); it++)
cout << *it << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> getMaxTeam(const vector<vector<bool>>& edges,
const vector<int>& set, vector<vector<int>>* answer) {
if (set.size() == 0) return (*answer)[0];
if (set.size() == 1) {
(*answer)[1 << set[0]].push_back(set[0]);
return set;
}
int index = 0;
for (int i = 0; i < set.size(); ++i) index += 1 << set[i];
if ((*answer)[index].size() > 0) return (*answer)[index];
int x = set.back();
vector<int> set1 = set;
set1.pop_back();
vector<int> team1 = getMaxTeam(edges, set1, answer);
vector<int> set2;
for (int i = 0; i < set.size() - 1; ++i)
if (!edges[x][set[i]]) set2.push_back(set[i]);
vector<int> team2 = getMaxTeam(edges, set2, answer);
team2.push_back(x);
if (team1.size() > team2.size()) {
(*answer)[index] = team1;
return team1;
} else {
(*answer)[index] = team2;
return team2;
}
}
int main() {
int n, m;
cin >> n >> m;
vector<string> data(n);
for (int i = 0; i < n; ++i) cin >> data[i];
vector<vector<bool>> edges(n, vector<bool>(n, false));
for (int i = 0; i < m; ++i) {
string s1, s2;
cin >> s1 >> s2;
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
if ((s1 == data[j]) && (s2 == data[k]))
edges[j][k] = edges[k][j] = true;
}
}
vector<int> set;
for (int i = 0; i < n; ++i) set.push_back(i);
vector<vector<int>> answer(1 << n);
vector<int> maxTeam = getMaxTeam(edges, set, &answer);
cout << maxTeam.size() << endl;
vector<string> team;
for (int i = 0; i < maxTeam.size(); ++i) team.push_back(data[maxTeam[i]]);
sort(team.begin(), team.end());
for (int i = 0; i < team.size(); ++i) cout << team[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int inf = (int)1e9;
map<string, int> mm;
const int maxn = 110;
int a[maxn][maxn];
int bc[maxn * maxn * 10];
string ss[maxn];
int main() {
int n, m;
cin >> n >> m;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
ss[i] = s;
mm[s] = i;
}
string s1, s2;
for (int i = 0; i < m; i++) {
cin >> s1 >> s2;
a[mm[s1]][mm[s2]] = 1;
a[mm[s2]][mm[s1]] = 1;
}
for (int i = 1; i < (1 << n); i++) bc[i] = bc[i >> 1] + (i & 1);
int res = 0, resm = 0;
for (int i = 1; i < (1 << n); i++) {
vector<int> v;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) v.push_back(j);
int good = 1;
for (int i1 = 0; i1 < ((int)(v).size()) && good; i1++)
for (int i2 = 0; i2 < ((int)(v).size()) && good; i2++)
if (a[v[i1]][v[i2]]) good = 0;
if (good && bc[i] > res) res = bc[i], resm = i;
}
cout << res << endl;
vector<string> vs;
for (int i = 0; i < n; i++)
if ((resm >> i) & 1) vs.push_back(ss[i]);
sort(vs.begin(), vs.end());
for (int i = 0; i < ((int)(vs).size()); i++) cout << vs[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ok(vector<string> &s, set<pair<string, string> > &st) {
int n = s.size();
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (st.find(make_pair(s[i], s[j])) != st.end()) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
set<pair<string, string> > st;
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
st.insert(make_pair(a, b));
st.insert(make_pair(b, a));
}
sort(v.begin(), v.end());
int val = 0;
vector<string> ret;
for (int bt = 0; bt < (1 << n); bt++) {
vector<string> cur;
for (int i = 0; i < n; i++)
if (bt & (1 << i)) cur.push_back(v[i]);
if (ok(cur, st)) {
int sz = cur.size();
if (val < sz) {
val = sz;
ret = cur;
}
}
}
cout << val << endl;
for (int i = 0; i < val; i++) cout << ret[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[30][30] = {};
int m, n;
bool ok(int tt) {
int i, j;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (((1 << i & tt) > 0) && ((1 << j & tt) > 0)) {
if (a[i][j] == 1) {
return 0;
}
}
return 1;
}
int countbit(int tt) {
int i, c = 0;
for (i = 0; i < n; i++)
if (((1 << i) & tt) > 0) c++;
return c;
}
int main() {
map<string, int> num;
string name[15], n1, n2;
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> name[i];
num[name[i]] = i;
}
for (i = 0; i < m; i++) {
cin >> n2 >> n1;
a[num[n1]][num[n2]] = 1;
a[num[n2]][num[n1]] = 1;
}
int res = 0;
for (i = 0; i < (1 << n); i++) {
if (ok(i) && (countbit(i) > countbit(res))) {
res = i;
}
}
string tmp;
cout << countbit(res) << "\n";
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (((1 << i & res) > 0) && ((1 << j & res) > 0))
if (name[j] < name[i]) {
tmp = name[i];
name[i] = name[j];
name[j] = tmp;
}
for (i = 0; i < n; i++)
if ((1 << i & res) > 0) cout << name[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, con, ans;
bool w[17][17];
string a[17], s[17], ts[17];
int ns[17];
int main() {
int i, j, k;
string t, u, v;
int nu, nv, cnt;
bool sign;
cin >> n >> m;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 1; i < n; ++i)
for (j = i + 1; j <= n; ++j)
if (a[i] > a[j]) {
t = a[i];
a[i] = a[j];
a[j] = t;
}
for (i = 1; i <= m; ++i) {
cin >> u >> v;
for (j = 1; j <= n; ++j)
if (u == a[j]) {
nu = j;
break;
}
for (j = 1; j <= n; ++j)
if (v == a[j]) {
nv = j;
break;
}
w[nu][nv] = true;
w[nv][nu] = true;
}
con = (1 << n) + 1;
for (i = 1; i <= con; ++i) {
cnt = 0;
for (j = 0; j < n; ++j) {
if ((i >> j) & 1 == 1) {
sign = true;
if (cnt > 0)
for (k = 1; k <= cnt; ++k)
if (w[ns[k]][j + 1] == true) {
sign = false;
break;
}
if (not sign) break;
ns[++cnt] = j + 1;
}
}
if (cnt > ans) {
ans = cnt;
for (j = 1; j <= cnt; ++j) s[j] = a[ns[j]];
}
}
for (i = 1; i < ans; ++i)
for (j = i + 1; j <= ans; ++j)
if (s[i] > s[j]) {
t = s[i];
s[j] = s[i];
s[i] = t;
}
cout << ans << "\n";
for (i = 1; i <= ans; ++i) cout << s[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[20], s0, s1, ans[20];
int g[20][20], ANS, n, tp[20];
void dfs(int now, int end, int cnt) {
if (now == end) {
for (int i = 0; i < cnt; i++)
for (int j = i + 1; j < cnt; j++)
if (g[tp[i]][tp[j]]) return;
if (cnt > ANS) {
ANS = cnt;
for (int i = 0; i < cnt; i++) ans[i] = s[tp[i]];
}
return;
}
tp[cnt] = now;
dfs(now + 1, end, cnt + 1);
dfs(now + 1, end, cnt);
}
int find(string x) {
for (int i = 0; i < n - 1; i++)
if (x == s[i]) return i;
return n - 1;
}
int main() {
int m;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 0; i < n; i++) cin >> s[i];
memset(g, 0, sizeof(g));
for (int i = 0; i < m; i++) {
cin >> s0 >> s1;
int id1 = find(s0);
int id2 = find(s1);
g[id1][id2] = g[id2][id1] = 1;
}
ANS = 0;
dfs(0, n, 0);
printf("%d\n", ANS);
sort(ans, ans + ANS);
for (int i = 0; i < ANS; i++) printf("%s\n", ans[i].c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
map<long long int, long long int> m1;
set<long long int> st;
long long int fep(long long int x, long long int y, long long int mod) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, i, m, j, k, x, y, a, b, p, sm = 0;
string s;
cin >> n >> p >> k;
for (i = 0; i < n; i++) {
cin >> x;
a = (x * x) % p;
a = (a * a) % p;
a -= (k * x) % p;
a = (a + p) % p;
st.insert(a);
m1[a]++;
}
set<long long int>::iterator it;
for (it = st.begin(); it != st.end(); it++) {
x = m1[*it];
sm += (x * (x - 1)) / 2;
}
cout << sm;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 3;
map<long long, long long> myp;
long long p;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long sub(long long x, long long y) {
long long ans = x - y;
if (ans < 0) ans = ans + p;
return ans;
}
long long mult(long long x, long long y) { return ((x % p) * (y % p)) % p; }
long long pw4(long long x) { return mult(mult(x, x), mult(x, x)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> p >> k;
long long ans = 0;
for (long long i = 0; i < (n); ++i) {
long long val;
cin >> val;
val = sub(pw4(val), mult(k, val));
ans += myp[val];
myp[val]++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 10, mod = 1e9 + 7;
int p;
int power(int a, int n) {
if (n == 0) return 1;
long long x = power(a, n / 2) % p;
x = (x * x) % p;
if (n & 1) return (x * a) % p;
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, i, x;
long long res = 0;
cin >> n >> p >> k;
unordered_map<int, int> mp;
for (i = 0; i < n; i++) {
cin >> x;
x = (power(x, 4) - (1LL * k * x) % p + p) % p;
mp[x]++;
}
for (auto y : mp) {
res += 1LL * y.second * (y.second - 1) / 2;
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, k, a[100001], x, ans;
unordered_map<long long, long long> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) {
cin >> x;
mp[(((x * x) % p * ((x * x) % p)) % p + p * p - k * x) % p]++;
}
for (auto it : mp) {
ans += it.second * (it.second - 1) / 2;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, k, ans, a[300010], t;
unordered_map<int, int> hp;
unordered_map<int, pair<int, int> > ph;
int cal(int x) {
long long t = (((1LL * x * x) % p) * ((1LL * x * x) % p)) % p;
t = (t - 1LL * x * k) % p;
t = (t % p + p) % p;
return t;
}
void readf() { cin >> n >> p >> k; }
void solve() {
for (int i = (1); i <= (n); ++i) cin >> a[i];
for (int i = (1); i <= (n); ++i) {
ans += hp[cal(a[i])];
hp[cal(a[i])]++;
}
for (int i = (1); i <= (n); ++i) {
if (ph[a[i]].second == 1)
t += ph[cal(a[i])].first;
else
ph[a[i]].second = 1;
ph[cal(a[i])].first++;
}
cout << ans - t;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
const int N = 3e5 + 11;
map<int, int> vis;
int n, k, p, a[N];
long long ans;
int g(int x) {
return (1ll * x * x % p * x % p * x % p - 1ll * k * x % p + 10ll * p) % p;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
ans += vis[g(a[i])];
vis[g(a[i])]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
int n, p, k;
cin >> n >> p >> k;
long long ans = 0;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
int t =
((long long)x * x % p * x % p * x % p - (long long)k * x % p + p) % p;
ans += mp[t];
mp[t]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, p, k;
cin >> n >> p >> k;
vector<long long> v(n);
for (long long &i : v) cin >> i;
map<pair<long long, long long>, long long> mapp;
long long curr = 1e9;
for (long long i : v) {
long long cur = i * i % p * i % p * i;
cur = (cur - k * i + curr * p) % p;
mapp[{cur, i}]++;
}
map<long long, pair<long long, long long> > temp;
for (auto u : mapp) {
temp[u.first.first].first += 1ll * u.second;
temp[u.first.first].second += 1ll * u.second * u.second;
}
long long ans = 0;
for (auto u : temp) {
ans += 1ll * u.second.first * u.second.first - u.second.second;
}
cout << ans / 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int cal(int inp, int p, int k) {
long long int cal = ((long long int)(inp % p) * (long long int)(inp % p)) % p;
cal = (cal * cal) % p;
cal -= ((long long int)k * inp) % p;
if (cal < 0) cal += p;
return (int)cal;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int n, p, k;
cin >> n >> p >> k;
int inp;
map<int, int> out;
for (int i = 0; i < n; i++) {
cin >> inp;
out[cal(inp, p, k)]++;
}
long long int ans = 0;
for (pair<int, int> f : out) {
ans += ((long long int)f.second * (f.second - 1)) / 2;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
long long getVal(long long x, long long rem, long long mod) {
long long val = x;
val = (val * x) % mod;
val = (val * x) % mod;
val = (val * x) % mod;
val -= (rem * x) % mod;
val += mod;
val %= mod;
return val;
}
int main() {
long long n, p, k;
scanf("%lld %lld %lld", &n, &p, &k);
map<int, int> cnt;
long long arr[n + 5];
for (int i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
arr[i] = getVal(arr[i], k, p);
cnt[arr[i]]++;
}
long long res = 0;
for (auto it = cnt.begin(); it != cnt.end(); it++) {
long long now = it->first;
long long have = it->second;
res += ((have) * (have - 1LL)) / 2LL;
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> mp;
int main() {
long long n, p, k;
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
mp[(((x * x % p) * (x * x % p) - k * x % p) % p + p) % p]++;
}
long long ans = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
ans += (it->second - 1ll) * (it->second) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long p;
long long k;
map<long long, long long> d;
long long kq;
int main() {
scanf("%d%lld%lld", &n, &p, &k);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
x = ((x * x % p * x % p * x % p - (x * k % p)) + p) % p;
kq += d[x];
d[x]++;
}
cout << kq;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, p, ans, l, r, i, j, k1, k0, a[100001];
map<long long, long long> t;
string s;
int main() {
cin >> n >> p >> k;
for (int i = 0; i < n; i++) {
long long v;
cin >> v;
long long o = ((v * v % p * v % p * v % p - k * v) % p + p) % p;
ans += t[o];
t[o]++;
;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, p, k, res = 0;
cin >> n >> p >> k;
for (long long int i = 0; i < n; i++) {
long long int x, y = 1;
cin >> x;
for (long long int j = 0; j < 4; j++) {
y *= x;
y %= p;
}
y -= (k * x) % p;
y %= p;
if (y < 0) y += p;
if (m.find(y) == m.end()) m.insert({y, 0});
m[y]++;
}
for (auto it = m.begin(); it != m.end(); it++)
res += (it->second) * (it->second - 1) / 2;
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<long long, long long> store;
long long n, p, k, result = 0;
cin >> n >> p >> k;
vector<long long> list(n);
for (int i = 0; i < n; i++) cin >> list[i];
for (auto el : list)
store[((((el * el) % p) * ((el * el) % p)) % p - (k * el) % p + p) % p] = 0;
for (auto el : list) {
result +=
store[((((el * el) % p) * ((el * el) % p)) % p - (k * el) % p + p) % p];
store[((((el * el) % p) * ((el * el) % p)) % p - (k * el) % p + p) % p]++;
}
cout << result << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p, i;
long long inp, temp;
scanf("%d %d %d", &n, &p, &k);
int a[n];
for (i = 0; i < n; i++) {
scanf("%I64d", &inp);
temp = inp;
temp = (temp * temp) % p;
temp = (temp * temp) % p;
temp = ((temp - inp * k) % p + p) % p;
a[i] = (int)temp;
}
sort(a, a + n);
long long ans = 0;
int cnt = 1;
for (i = 1; i < n; i++) {
if (a[i] == a[i - 1]) {
ans = ans + cnt;
cnt++;
} else {
cnt = 1;
}
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-Ofast")
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
long long int modexp(long long int a, long long int b, long long int mod) {
long long int x = 1;
while (b) {
if (b & 1) x = ((x % mod) * (a % mod)) % mod;
a = ((a % mod) * (a % mod)) % mod;
b = b / 2;
}
return x;
}
void rf() {}
void solve() {
long long int n, p, k;
cin >> n >> p >> k;
vector<long long int> a(n);
for (long long int i = 0; i < n; ++i) cin >> a[i];
map<long long int, long long int> mp;
long long int ans = 0;
for (int i = 0; i < n; ++i) {
long long int pw4 = modexp(a[i], 4, p);
long long int cur = (pw4 - (k * a[i]) % p) % p;
if (cur < 0) cur += p;
if (mp.find(cur) != mp.end()) ans += mp[cur];
mp[cur]++;
}
cout << ans << "\n";
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int mod;
long long qpow(long long a, long long b) {
long long ans = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
}
return ans;
}
long long gcd(long long a, long long b) { return b > 0 ? gcd(b, a % b) : a; }
long long a[maxn];
map<long long, int> M;
map<long long, int> mm;
int main() {
int n, m, T, p, k;
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
mod = p;
long long ans = 0;
if (k == 0) {
for (int i = 1; i <= n; i++) {
int x = p - qpow(a[i], 2), y = p - a[i];
ans = (ans + M[y]) % mod;
ans = (ans + mm[x]) % mod;
if (2ll * a[i] % mod * a[i] % mod == 0) {
ans = ((ans - M[y]) % mod + mod) % mod;
}
M[a[i]]++;
mm[a[i] * a[i] % mod]++;
}
} else {
for (int i = 1; i <= n; i++) {
long long temp =
((qpow(a[i], 4) - 1ll * k * a[i] % mod) % mod + mod) % mod;
ans = (ans + M[temp]) % mod;
M[temp]++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &val) {
int x = 0;
int bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, a[maxn];
unordered_map<long long, long long> mp;
int main() {
int k;
read(n);
read(m);
read(k);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) {
long long res = 1LL * a[i] * a[i] % m * a[i] % m * a[i] % m;
res = (res - 1LL * k * a[i] % m) % m + m;
res %= m;
mp[res]++;
}
long long ans = 0;
for (auto to : mp) {
long long num = to.second;
if (num <= 1) continue;
ans += (num * (num - 1)) / 2;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int calc(int p, int k, int a) {
long long ans = a;
ans = ans * ans;
ans %= p;
ans = ans * ans;
ans %= p;
ans -= ((long long)(k)*a);
ans %= p;
if (ans < 0) ans += p;
ans %= p;
return (int)ans;
}
int main() {
int n, p, k;
cin >> n >> p >> k;
vector<int> A(n);
for (int& x : A) cin >> x;
for (int& x : A) x = calc(p, k, x);
sort(A.begin(), A.end());
A.push_back(-1);
A.push_back(-2);
int cnt = 1;
int ans = 0;
for (int i = 1; i < A.size(); i++) {
if (A[i] == A[i - 1])
cnt++;
else {
ans += cnt * (cnt - 1) / 2;
cnt = 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 3e5;
int N;
long long P, K;
map<long long, int> cnt;
int main() {
scanf("%d %lld %lld", &N, &P, &K);
long long ans = 0;
for (int i = 1; i <= N; i++) {
long long x;
scanf("%lld", &x);
ans += cnt[((x * x % P) * (x * x % P) - K * x % P + P) % P];
cnt[((x * x % P) * (x * x % P) - K * x % P + P) % P]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int MOD = 1e9 + 7;
long long a[N];
map<long long, int> cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, p, k;
cin >> n >> p >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
long long d = a[i];
d *= a[i];
d %= p;
d *= a[i];
d %= p;
d *= a[i];
d %= p;
d -= (k * a[i]) % p;
d += p;
d %= p;
a[i] = d;
cnt[d]++;
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans += cnt[a[i]] - 1;
}
cout << ans / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long n, p, k, x, ans;
unordered_map<int, int> cnt;
int main() {
scanf("%lld%lld%lld", &n, &p, &k);
for (int i = 0; i < n; ++i) {
scanf("%lld", &x);
int key = ((k * x % p - x * x % p * x % p * x % p) % p + p) % p;
ans += cnt[key]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, p, k;
cin >> n >> p >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> v;
for (long long i = 0; i < n; i++) {
long long y = a[i];
y *= a[i];
y %= p;
y *= a[i];
y %= p;
y *= a[i];
y %= p;
y -= (a[i] * k) % p;
y += p;
y %= p;
v.push_back(y);
}
sort(v.begin(), v.end());
long long id = v[0];
long long cnt = 0;
long long ans = 0;
for (long long i = 0; i < v.size(); i++) {
if (v[i] == id) {
cnt++;
} else {
ans += ((cnt - 1) * cnt) / 2;
cnt = 1;
id = v[i];
}
}
ans += ((cnt - 1) * cnt) / 2;
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ms {
long long x;
int k;
ms(long long x, int k) : x(x), k(k){};
bool operator<(const ms &a) const { return x < a.x; }
};
int main() {
int n;
long long p, k;
cin >> n >> p >> k;
set<ms> a;
vector<long long> v;
int t = 0;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x;
y = x * x % p * x % p - k;
if (y < 0) y += p;
y = y * x % p;
ms m(y, t);
auto e = a.find(m);
if (e == a.end()) {
a.insert(m);
t++;
v.push_back(1);
} else {
v[e->k]++;
}
}
long long ans = 0;
for (auto c : v) ans += c * (c - 1) / 2;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, p, k;
map<long long, int> mp;
int main() {
while (~scanf("%I64d%I64d%I64d", &n, &p, &k)) {
mp.clear();
long long ans = 0LL;
for (int i = 1; i <= n; i++) {
long long ai;
scanf("%I64d", &ai);
long long ai4 = ai * ai % p * ai % p * ai % p;
long long a = (ai4 - ai * k % p + p) % p;
ans += mp[a]++;
}
printf("%I64d\n", ans);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.