text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 9;
map<string, int> mp;
string s[MAX], v[MAX], u[MAX];
int n, m, ans;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
sort(s, s + n);
for (int i = 0; i < n; i++) mp[s[i]] = i;
for (int i = 0; i < m; i++) cin >> v[i] >> u[i];
for (int i = 0; i < (1 << n); i++) {
bool f = 1;
for (int j = 0; j < m; j++)
if ((i & (1 << mp[v[j]])) && (i & (1 << mp[u[j]]))) f = 0;
if (f && __builtin_popcount(ans) < __builtin_popcount(i)) ans = i;
}
cout << __builtin_popcount(ans) << '\n';
for (int i = 0; i < n; i++)
if (ans & (1 << i)) cout << s[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int findPosition(vector<string> array, string name);
int countBits(int matrix);
int main() {
int numberOfVolunteers, numberOfExcludedPairs, firstPosition, secoundPosition;
vector<string> volunteers;
vector<short> excluded;
string name;
short matrix;
cin >> numberOfVolunteers;
cin >> numberOfExcludedPairs;
for (int i = 0; i < numberOfVolunteers; i++) {
cin >> name;
volunteers.push_back(name);
}
sort(volunteers.begin(), volunteers.end());
for (int i = 0; i < numberOfExcludedPairs; i++) {
cin >> name;
firstPosition = findPosition(volunteers, name);
cin >> name;
secoundPosition = findPosition(volunteers, name);
matrix = 0;
matrix |= (1 << firstPosition);
matrix |= (1 << secoundPosition);
excluded.push_back(matrix);
}
bool isValid;
int capacity, searchedCapacity = 0;
short searchedCombination = 0;
int maxVal = (1 << numberOfVolunteers);
for (int combination = 0; combination < maxVal; combination++) {
isValid = true;
for (int i = 0; i < excluded.size(); i++) {
if ((short)(excluded[i] & combination) == excluded[i]) isValid = false;
}
if (isValid) {
capacity = countBits(combination);
}
if (searchedCapacity < capacity) {
searchedCombination = combination;
searchedCapacity = capacity;
}
}
vector<string> result;
for (int i = 0; i < numberOfVolunteers; i++) {
if (searchedCombination & 1 == 1) result.push_back(volunteers[i]);
searchedCombination >>= 1;
}
cout << searchedCapacity << '\n';
for (int i = 0; i < result.size(); i++) {
cout << result[i] << '\n';
}
return 0;
}
int findPosition(vector<string> array, string name) {
for (int i = 0; i < array.size(); i++) {
if (array[i] == name) return i;
}
return -1;
}
int countBits(int matrix) {
int counter = 0;
while (matrix != 0) {
if (matrix & 1) counter++;
matrix >>= 1;
}
return counter;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> m1;
map<int, string> m2;
vector<pair<int, int>> pairs;
vector<string> names;
int main() {
int n, m, max = 0, sol = 0;
string name, name2;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> name;
names.push_back(name);
}
sort(names.begin(), names.end());
for (int i = 0; i < n; i++) {
m1[names[i]] = i;
}
for (int i = 0; i < m; i++) {
cin >> name >> name2;
pairs.push_back(make_pair(m1[name], m1[name2]));
}
for (int i = 0; i < (1 << n); i++) {
bool pos = true;
for (int j = 0; j < m; j++) {
if ((i & (1 << pairs[j].first)) && (i & (1 << pairs[j].second))) {
pos = false;
break;
}
}
if (pos && __builtin_popcount(i) > max) {
max = __builtin_popcount(i);
sol = i;
}
}
if (m != 0)
cout << max << endl;
else {
cout << n << endl;
for (int i = 0; i < n; i++) {
cout << names[i] << endl;
}
return 0;
}
for (int i = 0; i < n; i++) {
if (sol & (1 << i)) cout << names[i] << endl;
}
m1.clear();
pairs.clear();
names.clear();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> pos;
string s[20];
long long crash[20][20];
long long sol() {
string ss;
cin >> ss;
if (pos.count(ss))
return pos[ss];
else {
long long t = pos.size();
pos[ss] = t;
s[t] = ss;
return t;
}
}
int main() {
long long n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) sol();
for (int i = 0; i < m; i++) {
int ii, jj;
ii = sol();
jj = sol();
crash[ii][jj] = crash[jj][ii] = 1;
}
long long bs = -100;
vector<string> vs;
for (int mask = 0; mask < (1 << n); mask++) {
vector<long long> A;
long long pos = 0;
long long c = mask;
while (c) {
if (c % 2) A.push_back(pos);
pos++;
c /= 2;
}
bool isok = true;
for (int i = 0; i < A.size(); i++) {
for (int j = 0; j < i; j++) {
if (crash[A[i]][A[j]]) isok = false;
}
}
long long sz = A.size();
if (sz > bs && isok) {
bs = A.size();
vs.clear();
for (int i = 0; i < A.size(); i++) vs.push_back(s[A[i]]);
}
}
cout << bs << endl;
sort(vs.begin(), vs.end());
for (int i = 0; i < vs.size(); i++) cout << vs[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 16;
int main() {
int n, m;
cin >> n >> m;
vector<string> names(n);
for (int i = 0; i < n; ++i) cin >> names[i];
vector<vector<int> > w(n);
for (int i = 0; i < n; ++i) w[i].resize(n);
for (int i = 0; i < m; ++i) {
string name1, name2;
cin >> name1 >> name2;
int u, v;
for (int i = 0; i < n; ++i) {
if (name1 == names[i]) u = i;
if (name2 == names[i]) v = i;
}
w[u][v] = 1;
w[v][u] = 1;
}
bitset<MAXN> best;
for (int s = 0; s < (1 << n); ++s) {
bitset<MAXN> p(s);
bool ok = true;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (p[i] && p[j] && w[i][j]) ok = false;
if (ok)
if (p.count() > best.count()) best = p;
}
vector<string> res;
for (int i = 0; i < n; ++i)
if (best[i]) res.push_back(names[i]);
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < res.size(); ++i) cout << res[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
char name[16][13], *nx[16];
bool map[16][16], pick[17];
int n, m, max, 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 < max) 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;
max = 0;
for (i = 1; i < n2; ++i) {
tm = cal(i);
if (max < tm) {
max = 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", max);
for (i = 0; i < max; ++i) printf("%s\n", nx[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
string s[N], ans[N], q[N];
map<string, int> mp;
int ban[N][N], res, tot;
int n, m, vis[N];
void dfs(int u) {
if (u == n + 1) {
if (tot > res) {
res = tot;
for (int i = 1; i <= tot; i++) ans[i] = q[i];
}
return;
}
dfs(u + 1);
if (!vis[u]) {
for (int i = 1; i <= n; i++)
if (ban[u][i]) vis[i]++;
q[++tot] = s[u];
dfs(u + 1);
--tot;
for (int i = 1; i <= n; i++)
if (ban[u][i]) vis[i]--;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
mp[s[i]] = i;
}
for (int i = 1; i <= m; i++) {
string now1, now2;
cin >> now1 >> now2;
int u = mp[now1], v = mp[now2];
ban[u][v] = ban[v][u] = 1;
}
dfs(1);
cout << res << '\n';
sort(ans + 1, ans + res + 1);
for (int i = 1; i <= res; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void input(long &n) { scanf("%ld", &n); }
void input(long long &n) { scanf("%lld", &n); }
char temp[12], tempo[12];
void sort(char aNames[][12], long l, long r) {
long i = l;
long j = r;
long mid = (i + j) >> 1;
strcpy(tempo, aNames[mid]);
while (i <= j) {
while (strcmp(aNames[i], tempo) < 0) i++;
while (strcmp(aNames[j], tempo) > 0) j--;
if (i <= j) {
strcpy(temp, aNames[i]);
strcpy(aNames[i], aNames[j]);
strcpy(aNames[j], temp);
i++;
j--;
}
}
if (i < r) sort(aNames, i, r);
if (j > l) sort(aNames, l, j);
}
char name1[12], name2[12];
void input(long &n, long &m, char aNames[][12], bool a[][17]) {
input(n);
input(m);
for (long i = 0; i < n; i++) {
scanf("%s", aNames[i]);
}
sort(aNames, 0, n - 1);
for (long i = 0; i < n; i++) {
for (long j = 0; j < n; j++) a[i][j] = false;
}
for (long i = 0; i < m; i++) {
scanf("%s %s", name1, name2);
long id1, id2;
for (long j = 0; j < n; j++) {
if (strcmp(name1, aNames[j]) == 0) {
id1 = j;
}
if (strcmp(name2, aNames[j]) == 0) {
id2 = j;
}
}
a[id1][id2] = a[id2][id1] = true;
}
}
void save(long n, bool tempx[], bool x[]) {
for (long i = 0; i < n; i++) x[i] = tempx[i];
}
void dosolve(long n, bool a[][17], bool tempx[], long id, long tempcount,
bool x[], long &count) {
if (id >= n) {
if (tempcount > count) {
save(n, tempx, x);
count = tempcount;
}
return;
}
for (long j = id; j < n; j++) {
bool bConflict = false;
for (long i = 0; i < n; i++)
if (tempx[i] && a[i][j]) {
bConflict = true;
break;
}
if (bConflict) continue;
tempx[j] = true;
dosolve(n, a, tempx, j + 1, tempcount + 1, x, count);
tempx[j] = false;
if (count == n) return;
}
dosolve(n, a, tempx, n, tempcount, x, count);
}
void solve(long n, long m, bool a[][17], bool x[], bool tempx[]) {
for (long i = 0; i < n; i++) tempx[i] = x[i] = false;
x[0] = true;
long count = 1;
dosolve(n, a, tempx, 0, 0, x, count);
}
void output(long n) { printf("%ld\n", n); }
void output(long n, char aNames[][12], bool x[]) {
long count = 0;
for (long i = 0; i < n; i++)
if (x[i]) count++;
output(count);
for (long i = 0; i < n; i++)
if (x[i]) printf("%s\n", aNames[i]);
}
long n, m;
char aNames[17][12];
bool a[17][17], x[17], tempx[17];
int main() {
input(n, m, aNames, a);
solve(n, m, a, x, tempx);
output(n, aNames, x);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> name(n);
map<string, int> mm;
for (int i = 0; i < n; i++) {
cin >> name[i];
mm[name[i]] = i;
}
vector<vector<int> > ng(n, vector<int>(n, 0));
for (int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
ng[mm[s1]][mm[s2]] = 1;
ng[mm[s2]][mm[s1]] = 1;
}
vector<string> ans;
for (int x = (1 << n) - 1; x >= 0; x--) {
vector<int> v;
for (int i = 0; i < n; i++) {
if (x & (1 << i)) v.push_back(i);
}
bool ok = true;
for (size_t i = 0; ok && i < v.size(); i++) {
for (size_t j = i + 1; ok && j < v.size(); j++) {
if (ng[v[i]][v[j]]) {
ok = false;
}
}
}
if (ok && ans.size() < v.size()) {
ans.clear();
for (size_t i = 0; i < v.size(); i++) {
ans.push_back(name[v[i]]);
}
sort(ans.begin(), ans.end());
}
}
cout << ans.size() << endl;
for (size_t i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1000000007;
long long int exp(long long int x, long long int n) {
if (n == 0) return 1;
if (n == 1) return x % INF;
if (n % 2 == 0)
return exp((x * x) % INF, n / 2);
else
return (x * exp((x * x) % INF, n / 2)) % INF;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, i, j;
long long int n, m;
cin >> n >> m;
vector<string> gh;
for (i = 0; i < n; i++) {
string k;
cin >> k;
gh.push_back(k);
}
pair<string, string> no[m];
for (i = 0; i < m; i++) {
string k, tp;
cin >> k >> tp;
no[i].first = k;
no[i].second = tp;
}
long long int g = pow(2, n);
vector<string> temp;
vector<string> ans;
long long int k1 = 0, k2 = 0, flag = 0, cur = 0;
for (i = g - 1; i >= 1; i--) {
temp.clear();
for (j = 0; j < n; j++) {
if (i & (1 << j)) {
temp.push_back(gh[j]);
}
}
flag = 0;
for (long long int b = 0; b < m; b++) {
k1 = 0;
k2 = 0;
for (long long int a = 0; a < temp.size(); a++) {
if (temp[a] == no[b].first) k1 = 1;
if (temp[a] == no[b].second) k2 = 1;
}
if (k1 == 1 && k2 == 1) {
flag = 1;
break;
}
}
if (flag == 0) {
if (temp.size() > cur) {
cur = temp.size();
ans.clear();
ans = temp;
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000000 + 7;
const long long int N = 1000000 + 6;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
string arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
vector<pair<string, string> > v;
for (int i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
v.push_back({x, y});
}
long long int x = pow(2, n) - 1;
vector<string> ans;
for (int i = 1; i <= x; i++) {
int j = 0;
vector<string> t;
map<string, long long int> ma;
while ((1 << j) <= i) {
if (((1 << j) & i) != 0) {
t.push_back(arr[j]);
ma[arr[j]]++;
}
j++;
}
bool bo = true;
for (long long int k = 0; k < m; k++) {
if (ma[v[k].first] != 0 and ma[v[k].second] != 0) {
bo = false;
break;
}
}
if (bo) {
if (t.size() > ans.size()) {
ans.clear();
for (int k = 0; k < t.size(); k++) {
ans.push_back(t[k]);
}
}
}
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> func(vector<string> &v, vector<pair<string, string>> vg,
vector<string>::iterator it) {
if (it != v.end()) v.erase(it);
vector<string> a = v;
vector<string> b = v;
for (int i = 0; i < vg.size(); i++) {
auto it = find(a.begin(), a.end(), vg[i].first);
auto it1 = find(b.begin(), b.end(), vg[i].second);
if ((it != a.end()) and (it1 != b.end())) {
a = func(a, vg, it);
b = func(b, vg, it1);
if (a.size() >= b.size()) {
v = a;
} else
v = b;
break;
}
}
return v;
}
void func(vector<string> &v, vector<pair<string, string>> vg) {
vector<string> a = v;
vector<string> b = v;
for (int i = 0; i < vg.size(); i++) {
auto it = find(a.begin(), a.end(), vg[i].first);
auto it1 = find(b.begin(), b.end(), vg[i].second);
if ((it != a.end()) and (it1 != b.end())) {
a = func(a, vg, it);
b = func(b, vg, it1);
if (a.size() >= b.size()) {
v = a;
} else
v = b;
break;
}
}
sort(v.begin(), v.end());
}
int main() {
int n, m;
string t, a, b;
vector<string> v;
vector<pair<string, string>> dg;
cin >> n;
cin >> m;
for (int i = 0; i < n; i++) {
cin >> t;
v.push_back(t);
}
for (int i = 0; i < m; i++) {
cin >> a;
cin >> b;
pair<string, string> p(a, b);
dg.push_back(p);
}
func(v, dg);
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string to_string(char s) { return "\'" + string(1, s) + "\'"; }
string to_string(string s) { return "\"" + s + "\""; }
template <typename T>
string to_string(vector<T>);
template <typename T>
string to_string(set<T>);
template <typename U, typename V>
string to_string(map<U, V>);
template <typename U, typename V>
string to_string(pair<U, V> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename T>
string to_string(vector<T> v) {
string s = "[ ";
for (auto e : v) s += to_string(e) + " ";
s += "]";
return s;
;
}
template <typename T>
string to_string(set<T> v) {
string s = "[ ";
for (auto e : v) s += to_string(e) + " ";
s += "]";
return s;
;
}
template <typename U, typename V>
string to_string(map<U, V> v) {
string s = "[ ";
for (auto e : v) s += to_string(e) + " ";
s += "]";
return s;
;
}
int n, m;
int maxp;
int ans;
char s[13];
char x[13];
char y[13];
vector<vector<int> > adj;
map<int, string> name;
map<string, int> number;
void calc(int bitmask, int i, int cnt) {
if (cnt > maxp) {
maxp = cnt;
ans = bitmask;
}
if (i == n) return;
int c = 0;
for (int j = 0; j < (int)adj[i].size(); j++)
if ((bitmask & (1 << adj[i][j]))) c++;
if (c == 0) calc(bitmask | (1 << i), i + 1, cnt + 1);
calc(bitmask, i + 1, cnt);
}
int main() {
scanf("%d %d", &n, &m);
adj.assign(n, vector<int>(0));
int no = 0;
for (int i = 0; i < n; i++) {
scanf("%s", s);
number[string(s)] = no;
name[no++] = string(s);
}
for (int i = 0; i < m; i++) {
scanf("%s %s", x, y);
int u = number[string(x)];
int v = number[string(y)];
adj[u].push_back(v);
adj[v].push_back(u);
}
calc(0, 0, 0);
vector<string> anss;
printf("%d\n", maxp);
for (int i = 0; i < n; i++) {
if ((ans & (1 << i))) anss.push_back(name[i]);
}
sort(anss.begin(), anss.end());
for (int i = 0; i < (int)anss.size(); i++) printf("%s\n", anss[i].data());
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T cube(T x) {
return x * sqr(x);
}
string out(long long x) {
stringstream ss;
ss << x;
string res;
ss >> res;
return res;
}
long long out(string s) {
stringstream ss;
ss << s;
long long res;
ss >> res;
return res;
}
const int MAXN = 16 + 1;
bool isbad[MAXN][MAXN];
int main() {
int n, m;
cin >> n >> m;
map<string, int> M;
vector<string> MM;
for (int i = 0; i < (n); i++) {
string s;
cin >> s;
M[s] = i;
MM.push_back(s);
}
for (int kkk = 0; kkk < (m); kkk++) {
string s1, s2;
cin >> s1 >> s2;
isbad[M[s1]][M[s2]] = true;
isbad[M[s2]][M[s1]] = true;
}
int res = -1;
vector<string> p;
for (int mask = 0; mask < (1 << n); mask++) {
vector<int> v;
for (int i = 0; i < (n); i++) {
if ((1 << i) & mask) v.push_back(i);
}
bool f = true;
for (int i = 0; i < (v.size()); i++) {
for (int j = 0; j < (v.size()); j++) {
if (i == j) continue;
if (isbad[v[i]][v[j]]) {
f = false;
}
}
}
if (f) {
if (res < (int)v.size()) {
p.clear();
p.resize(v.size());
for (int i = 0; i < (p.size()); i++) {
p[i] = MM[v[i]];
}
res = v.size();
}
}
}
sort(p.begin(), p.end());
cout << res << endl;
for (int i = 0; i < (res); i++) {
cout << p[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<string, string>> v;
set<string> getTeam(set<string> t, map<string, int> s, string e, int i) {
if (e != "") {
t.erase(t.find(e));
s[" " + (e + " ")]++;
}
while ((v.begin() + i) != v.end() && (s[(" " + v[i].first) + " "] != 0 ||
s[(" " + v[i].second) + " "] != 0))
++i;
if (v.begin() + i == v.end()) return t;
set<string> s1 = getTeam(t, s, v[i].first, i);
set<string> s2 = getTeam(t, s, v[i].second, i);
if (s1.size() >= s2.size()) return s1;
return s2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string x, y;
set<string> se;
map<string, int> ma;
int n, m;
cin >> n >> m;
while (n--) {
cin >> x;
se.insert(x);
ma[(" " + x) + " "] = 0;
}
while (m--) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
se = getTeam(se, ma, "", 0);
cout << se.size() << "\n";
for (auto i = se.begin(); i != se.end(); ++i) cout << (*i) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string a[20];
map<string, int> mapp;
vector<int> vv[20], v;
int ma = -1;
vector<string> ans;
void dfs() {
if (v.size() == n) {
int f = 1, s = 0;
for (int i = 0; i < n; i++) {
if (v[i]) {
s++;
for (int j = 0; j < vv[i + 1].size(); j++) {
if (v[vv[i + 1][j] - 1] == 1) {
f = 0;
}
}
}
}
if (f == 1) {
if (ma < s) {
ans.clear();
for (int i = 0; i < n; i++) {
if (v[i]) {
ans.push_back(a[i + 1]);
}
}
ma = s;
}
}
} else {
v.push_back(0);
dfs();
v.pop_back();
v.push_back(1);
dfs();
v.pop_back();
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mapp[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
string x, y;
cin >> x >> y;
vv[mapp[x]].push_back(mapp[y]);
vv[mapp[y]].push_back(mapp[x]);
}
dfs();
sort(ans.begin(), ans.end());
cout << ma << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, n2, anss = -1;
string temp, temp2, ar[17];
map<string, vector<string> > name_toHate;
set<string> s, ans;
set<string>::iterator it;
void calc(int it, bool take, set<string> s1, int size) {
if (it == n) {
if (size > anss) {
anss = size;
ans = s1;
}
} else {
if (take) {
int ts = name_toHate[ar[it]].size();
for (int i = 0; i < ts; i++) {
if (s1.find(name_toHate[ar[it]][i]) != s1.end()) {
size--;
s1.erase(s1.find(name_toHate[ar[it]][i]));
}
}
size++;
s1.insert(ar[it]);
calc(it + 1, true, s1, size);
calc(it + 1, false, s1, size);
} else {
calc(it + 1, true, s1, size);
calc(it + 1, false, s1, size);
}
}
}
int main() {
scanf("%d%d", &n, &n2);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n2; i++) {
cin >> temp >> temp2;
name_toHate[temp].push_back(temp2);
name_toHate[temp2].push_back(temp);
}
calc(0, false, s, 0);
calc(0, true, s, 0);
printf("%d\n", anss);
for (it = ans.begin(); it != ans.end(); it++) {
cout << *it << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<string> getTeam(set<string> t, map<string, int> s,
vector<pair<string, string>> v, string e, int i) {
if (e != "") {
t.erase(t.find(e));
s[" " + (e + " ")]++;
}
while ((v.begin() + i) != v.end() && (s[(" " + v[i].first) + " "] != 0 ||
s[(" " + v[i].second) + " "] != 0))
++i;
if (v.begin() + i == v.end()) return t;
set<string> s1 = getTeam(t, s, v, v[i].first, i);
set<string> s2 = getTeam(t, s, v, v[i].second, i);
if (s1.size() >= s2.size()) return s1;
return s2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string x, y;
set<string> se;
vector<pair<string, string>> xy;
map<string, int> ma;
int n, m;
cin >> n >> m;
while (n--) {
cin >> x;
se.insert(x);
ma[(" " + x) + " "] = 0;
}
while (m--) {
cin >> x >> y;
xy.push_back(make_pair(x, y));
}
se = getTeam(se, ma, xy, "", 0);
cout << se.size() << "\n";
for (auto i = se.begin(); i != se.end(); ++i) cout << (*i) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
string s[MAXN];
map<string, int> num;
map<int, string> name;
bool mark[MAXN][MAXN];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
num[s[i]] = i;
name[i] = s[i];
}
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
mark[num[a]][num[b]] = true;
mark[num[b]][num[a]] = true;
}
int t = 0;
int ans = -1;
for (int i = 0; i < (1 << n); i++) {
int tedad = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) tedad++;
bool ch = true;
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
if ((i & (1 << j)) && (i & (1 << k))) {
if (mark[j][k]) {
ch = false;
break;
}
}
if (ch) {
if (t < tedad) {
t = tedad;
ans = i;
}
}
}
vector<string> vec;
for (int i = 0; i < n; i++)
if (ans & (1 << i)) vec.push_back(name[i]);
sort(vec.begin(), vec.end());
cout << vec.size() << endl;
for (int i = 0; i < (int)vec.size(); i++) cout << vec[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<string, int> mp;
vector<string> v, u;
vector<pair<int, int> > clash;
bool isValid(int mask) {
for (int i = 0; i < m; i++) {
if ((mask & (1 << clash[i].first)) && (mask & (1 << clash[i].second))) {
return false;
}
}
return true;
}
int bitCount(int mask) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) cnt++;
}
return cnt;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
mp[s] = i;
v.push_back(s);
}
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
clash.push_back(make_pair(mp[a], mp[b]));
}
int ans = 0;
int mask = 0;
for (int i = 0; i < (1 << n); i++) {
if (isValid(i)) {
int cnt = bitCount(i);
if (cnt >= ans) {
ans = cnt;
mask = i;
}
}
}
cout << ans << endl;
if (ans) {
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) u.push_back(v[i]);
}
}
sort(u.begin(), u.end());
for (int i = 0; i < u.size(); i++) {
cout << u[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> tbl;
int n, e[16][16];
inline int bit(int x, int i) { return (x >> i) & 1; }
bool chk(int s) {
for (int j = 0; j < n; j++)
if (bit(s, j))
for (int k = j + 1; k < n; k++)
if (bit(s, k))
if (e[j][k]) return 0;
return 1;
}
int main() {
int m, x, y;
char a[100], b[100], name[100][100];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", name[i]);
tbl[name[i]] = i;
}
while (m--) {
scanf("%s %s", a, b);
x = tbl[a];
y = tbl[b];
e[x][y] = e[y][x] = 1;
}
int ans = 0, sol = 0;
for (int i = 0; i < (1 << n); i++) {
int cnt = __builtin_popcount(i);
if (cnt <= ans || !chk(i)) continue;
ans = cnt;
sol = i;
}
vector<string> v;
for (int i = 0; i < n; i++)
if (bit(sol, i)) v.push_back(name[i]);
sort(v.begin(), v.end());
printf("%d\n", ans);
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
printf("%s\n", it->c_str());
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 (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;
const int N = 30;
string s[N], ans[N], q[N];
map<string, int> mp;
int ban[N][N], res, tot;
int n, m, vis[N];
void dfs(int u) {
if (u == n + 1) {
if (tot > res) {
res = tot;
for (int i = 1; i <= tot; i++) ans[i] = q[i];
}
return;
}
dfs(u + 1);
if (!vis[u]) {
for (int i = 1; i <= n; i++)
if (ban[u][i]) vis[i]++;
q[++tot] = s[u];
dfs(u + 1);
--tot;
for (int i = 1; i <= n; i++)
if (ban[u][i]) vis[i]--;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
mp[s[i]] = i;
}
for (int i = 1; i <= m; i++) {
string now1, now2;
cin >> now1 >> now2;
int u = mp[now1], v = mp[now2];
ban[u][v] = ban[v][u] = 1;
}
dfs(1);
cout << res << '\n';
sort(ans + 1, ans + res + 1);
for (int i = 1; i <= res; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
string s[20];
pair<string, string> p[150];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
char x[15];
scanf("%s", x);
s[i] = (string)x;
}
for (int i = 0; i < m; i++) {
char x[12], y[12];
scanf("%s%s", &x, &y);
p[i] = {(string)x, (string)y};
}
vector<string> res;
for (int i = 0; i < (1 << n); i++) {
int ii = i;
int cnt = 0;
vector<string> v;
while (ii) {
if (ii & 1) {
v.push_back(s[cnt]);
}
ii = ii >> 1;
cnt++;
}
bool f = 1;
for (int j = 0; j < v.size(); j++) {
for (int k = 0; k < v.size(); k++) {
for (int l = 0; l < m; l++) {
if (v[j] == p[l].first && v[k] == p[l].second) f = 0;
}
}
}
if (f && v.size() > res.size()) {
res = v;
}
}
sort(res.begin(), res.end());
printf("%d\n", res.size());
for (int i = 0; i < res.size(); i++) {
printf("%s\n", res[i].c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[22];
map<string, int> id;
int bad[22][22];
int main() {
int n, k;
while (cin >> n >> k) {
memset(bad, 0, sizeof bad);
id.clear();
for (int i = 0, _a = (n); i < _a; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0, _a = (n); i < _a; i++) id[a[i]] = i;
for (int i = 0, _a = (k); i < _a; i++) {
string x, y;
cin >> x >> y;
bad[id[x]][id[y]] = 1;
}
int best = 0, save = 0;
for (int mask = 0, _a = ((1 << (n))); mask < _a; mask++)
if (__builtin_popcount(mask) > best) {
int sum = 0;
for (int i = 0, _a = (n); i < _a; i++)
if ((mask & (1 << (i))))
for (int j = 0, _a = (n); j < _a; j++)
if ((mask & (1 << (j)))) sum += bad[i][j];
if (sum == 0) {
best = __builtin_popcount(mask);
save = mask;
}
}
cout << best << endl;
for (int i = 0, _a = (n); i < _a; i++)
if ((save & (1 << (i)))) cout << a[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, x, y, z, fl, sum, count, n, m;
string c, d;
vector<string> e;
map<string, long long> ma;
map<long long, string> ma1;
long long a[20];
long long adj[20][20];
for (i = 0; i < 20; i++)
for (j = 0; j < 20; j++) adj[i][j] = 0;
scanf("%lld%lld", &n, &m);
for (i = 0; i < n; i++) {
cin >> c;
e.push_back(c);
}
sort(e.begin(), e.end());
for (i = 0; i < n; i++) {
ma[e[i]] = i;
ma1[i] = e[i];
}
for (i = 0; i < m; i++) {
cin >> c >> d;
x = ma[c];
y = ma[d];
adj[x][y] = 1;
adj[y][x] = 1;
}
vector<long long> b, de;
count = -1;
for (i = 0; i < (1 << n); i++) {
sum = 0;
for (j = 0; j < n; j++) {
if ((i & (1 << j)) != 0) {
b.push_back(j);
sum++;
}
}
fl = 0;
for (j = 0; j < b.size(); j++)
for (k = j + 1; k < b.size(); k++)
if (adj[b[j]][b[k]] == 1) {
fl = 1;
break;
}
if (fl == 0 && count < sum) {
count = sum;
de.clear();
for (j = 0; j < b.size(); j++) de.push_back(b[j]);
continue;
}
b.clear();
}
printf("%lld\n", count);
for (i = 0; i < de.size(); i++) cout << ma1[de[i]] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
map<int, string> names;
map<string, int> id;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
names[i] = s;
id[s] = i;
}
vector<pair<int, int>> dg;
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
dg.emplace_back(id[a], id[b]);
}
int prospect = -1, con = 1e4;
int base = pow(2, n) - 1;
for (int i = 1; i <= base; i++) {
int conflict = 0;
for (auto it : dg) {
int x = it.first, y = it.second;
if ((1 & (i >> x)) && (1 & (i >> y))) {
conflict++;
}
}
if (conflict < con) {
prospect = i;
con = conflict;
} else if (conflict == con) {
int comp = __builtin_popcount(i);
int comp2 = __builtin_popcount(prospect);
if (comp > comp2) {
prospect = i;
}
}
}
vector<string> ans;
for (int i = 0; i < 32; i++) {
if (1 & (prospect >> i)) {
ans.push_back(names[i]);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto it : ans) {
cout << it << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
string str[16];
int n, m;
bool graph[16][16];
int countbit(int x) {
int k = 0;
while (x > 0) {
k += x % 2;
x /= 2;
}
return k;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> str[i];
mp[str[i]] = i;
}
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;
}
int ans = 0;
for (int state = 0; state < (1 << n); state++) {
if (countbit(ans) >= countbit(state)) continue;
bool flag = true;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if ((state & (1 << i)) && (state & (1 << j)) && graph[i][j])
flag = false;
if (flag) ans = state;
}
vector<string> res;
for (int i = 0; i < n; i++)
if (ans & (1 << i)) res.push_back(str[i]);
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int n, m, id;
string str[17], t1, t2;
bool con[17][17];
int get(int s) {
int ret(0);
for (int i = 0; i < n; i++) {
if (s & (1 << i)) ret++;
for (int j = 0; j < i; j++)
if ((s & (1 << i)) && (s & (1 << j)))
if (con[i][j]) {
return 0;
}
}
return ret;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
id = 0;
for (int i = 1; i <= n; i++) cin >> str[i];
sort(str + 1, str + n + 1);
mp.clear();
for (int i = 1; i <= n; i++) mp[str[i]] = i - 1;
memset(con, 0, sizeof(con));
for (int i = 1; i <= m; i++) {
cin >> t1 >> t2;
int x = mp[t1], y = mp[t2];
con[x][y] = con[y][x] = 1;
}
int ans = 0, tmp, ps;
for (int i = 0; i < (1 << n); i++) {
tmp = get(i);
if (tmp > ans) ans = tmp, ps = i;
}
printf("%d\n", ans);
for (int i = 0; i < n; i++)
if (ps & (1 << i)) cout << str[i + 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[16];
int n, m;
int adj[16][16];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
while (m--) {
string x, y;
cin >> x >> y;
int i = lower_bound(a, a + n, x) - a;
int j = lower_bound(a, a + n, y) - a;
adj[i][j] = adj[j][i] = 1;
}
int bb = -1, mm = 0;
for (int mask = 0; mask < (1 << n); mask++) {
int ok = 1;
for (int i = 0; i < n; i++)
if (mask & (1 << i))
for (int j = 0; j < n; j++)
if (mask & (1 << j))
if (adj[i][j]) ok = 0;
if (ok) {
int b = __builtin_popcount(mask);
if (b > bb) {
bb = b;
mm = mask;
}
}
}
cout << bb << '\n';
for (int i = 0; i < n; i++)
if (mm & (1 << i)) cout << a[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int main() {
int n, m;
map<string, int> names;
cin >> n >> m;
string n1, n2;
vector<string> name(n);
for (int i = (0); i < (n); i++) cin >> name[i];
sort((name).begin(), (name).end());
for (int i = (0); i < (n); i++) names[name[i]] = i;
vector<int> mask;
for (int i = (0); i < (m); i++) {
cin >> n1 >> n2;
mask.push_back((1 << names[n1]) | (1 << names[n2]));
}
int Result = 0;
int ndTeam = 0;
for (int p = (0); p < ((1 << n)); p++) {
int team = 0, nums = 0;
for (int i = (0); i < (n); i++)
if ((1 << i) & p) {
team |= (1 << i);
++nums;
}
int ok = true;
for (int i = (0); i < (int((mask).size())); i++)
if ((team & mask[i]) == mask[i]) ok = false;
if (ok && nums > Result) Result = nums, ndTeam = team;
}
cout << Result << endl;
for (int i = (0); i < (n); i++)
if ((1 << i) & ndTeam) cout << name[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
map<string, set<string>> hate;
string names[17];
vector<string> ans;
int dp[17][1 << 17];
int solve(int idx, int mask) {
if (idx == N) return 0;
if (dp[idx][mask] != -1) return dp[idx][mask];
dp[idx][mask] = solve(idx + 1, mask);
bool canTake = true;
for (int i = 0; i < N; i++) {
if (i == idx) continue;
if ((1 << i) & mask) {
for (set<string>::iterator it = hate[names[i]].begin();
it != hate[names[i]].end(); it++) {
if (names[idx] == *it) canTake = false;
}
}
}
if (canTake)
dp[idx][mask] = max(dp[idx][mask], solve(idx + 1, mask | (1 << idx)) + 1);
return dp[idx][mask];
}
void print(int idx, int mask) {
if (idx == N) return;
if (dp[idx][mask] == solve(idx + 1, mask))
print(idx + 1, mask);
else if (dp[idx][mask] == solve(idx + 1, mask | (1 << idx)) + 1) {
ans.push_back(names[idx]);
print(idx + 1, mask | (1 << idx));
}
}
int main() {
cin >> N >> M;
string first, second;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < N; i++) {
cin >> names[i];
}
for (int i = 0; i < M; i++) {
cin >> first >> second;
hate[first].insert(second);
hate[second].insert(first);
}
cout << solve(0, 0) << endl;
print(0, 0);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
char s[40];
} name[20];
char a[40];
char b[40];
int g[20][20];
int c[20];
bool cmp(E A, E B) { return strcmp(A.s, B.s) < 1; }
int main() {
int n, m, i, j, k, t, kq = 0, kqb;
scanf("%d", &n);
scanf("%d", &m);
for (i = 0; i < n; i++) {
scanf("%s", &name[i].s);
}
sort(name, name + n, cmp);
for (i = 0; i < m; i++) {
scanf("%s %s", &a, &b);
for (j = 0; j < n; j++)
if (strcmp(a, name[j].s) == 0) break;
for (k = 0; k < n; k++)
if (strcmp(b, name[k].s) == 0) break;
g[j][k] = g[k][j] = 1;
}
for (i = 0; i < (1 << n); i++) {
k = i;
for (j = 0; j < n; j++) {
c[j] = k % 2;
k /= 2;
}
t = 1;
for (j = 0; j < n && t; j++)
if (c[j])
for (k = 0; k < n && t; k++)
if (c[k]) {
if (g[j][k]) t = 0;
}
if (t) {
t = 0;
for (j = 0; j < n; j++) t += c[j];
if (kq < t) {
kq = t;
kqb = i;
}
}
}
cout << kq << endl;
for (j = 0; j < n; j++) {
c[j] = kqb % 2;
if (c[j]) cout << name[j].s << endl;
kqb /= 2;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int g[16][16];
map<string, int> hsh;
string tmp, tmp2, a[16];
int ans = 0;
void dfs(int dep, int s) {
if (dep >= n) {
if (__builtin_popcount(s) > __builtin_popcount(ans)) ans = s;
} else {
dfs(dep + 1, s);
for (int i = 0; i < n; i++)
if (g[dep][i] && (s & (1 << i))) return;
dfs(dep + 1, s | (1 << dep));
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) hsh[a[i]] = i;
for (int i = 0; i < m; i++) {
cin >> tmp >> tmp2;
g[hsh[tmp]][hsh[tmp2]] = g[hsh[tmp2]][hsh[tmp]] = 1;
}
dfs(0, 0);
cout << __builtin_popcount(ans) << endl;
for (int i = 0; i < n; i++)
if (ans & (1 << i)) cout << a[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxSize = 1 << 16;
map<string, int> t;
int a[maxSize];
vector<string> s;
vector<vector<int> > v;
int main() {
int n, k;
scanf("%d%d", &n, &k);
v.resize(n);
s.resize(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
t[s[i]] = i;
}
for (int i = 0; i < k; i++) {
string s1, s2;
cin >> s1 >> s2;
int x, y;
x = t[s1], y = t[s2];
v[x].push_back(y);
v[y].push_back(x);
}
int res = 0, ans = 0;
for (int i = 0; i < maxSize; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
for (int j = 0; j < n; j++)
if (i & (1 << j))
for (int x = 0; x < v[j].size(); x++)
if (i & (1 << v[j][x])) {
cnt = 0;
break;
}
if (cnt > ans) res = i, ans = cnt;
}
printf("%d\n", ans);
set<string> st;
for (int i = 0; i < n; i++)
if (res & (1 << i)) st.insert(s[i]);
for (auto e : st) cout << e << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void re(int b[19], int n) {
for (int i = 1; i <= n; i++) b[i]++;
}
int num(int b[17], int n) {
int res = 0;
for (int i = 1; i <= n; i++)
if (b[i] == 1) res++;
return res;
}
int c = 0;
int ma[17], a[17];
int big;
bool enemy[20][20];
bool flag;
void dfs(int i, int n) {
int t;
if (i == n + 1) {
c = 1;
flag = 1;
while (flag && c <= n) {
if (a[c] == 1) {
int j = 1;
while (flag && j <= n) {
if (enemy[c][j] && a[j] == 1) flag = 0;
j++;
}
}
c++;
}
if (flag) {
t = num(a, n);
if (t > big) {
for (int z = 1; z <= n; z++) ma[z] = a[z];
big = t;
}
}
} else {
a[i] = 1;
if (i <= n) dfs(i + 1, n);
a[i] = 0;
if (i <= n) dfs(i + 1, n);
}
}
int main() {
char ftp[20];
int n, m, i, j, k;
string f, s[20], ans[20];
int a[20];
vector<int> v;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%s", &ftp);
s[i] = string(ftp);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) enemy[i][j] = 0;
if (m != 0) scanf("\n");
char ch;
for (i = 1; i <= m; i++) {
f = "";
ch = '\0';
while (ch != ' ') {
scanf("%c", &ch);
if (ch != ' ') f += ch;
}
bool ok = 1;
j = 1;
while (ok && j <= n) {
if (s[j] == f) ok = 0;
j++;
}
j--;
f = "";
while (ch != '\n') {
scanf("%c", &ch);
if (ch != '\n') f += ch;
}
ok = 1;
k = 1;
while (ok && j <= n) {
if (s[k] == f) ok = 0;
k++;
}
k--;
enemy[j][k] = enemy[k][j] = 1;
}
dfs(1, n);
printf("%d\n", big);
c = 0;
for (i = 1; i <= n; i++)
if (ma[i] == 1) {
c++;
s[c] = s[i];
}
s[0] = "";
s[0] += 1;
sort(s, s + c + 1);
for (i = 1; i <= c; i++) {
cout << s[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> ma;
string s[17];
bool p[17][17];
vector<int> vec, ret;
bool ok() {
for (int i = 0; i < vec.size(); i++)
for (int k = 0; k < vec.size(); k++)
if (p[vec[i]][vec[k]]) return false;
return true;
}
bool comp(int a, int b) { return s[a] < s[b]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, i, u, v, k;
string a, b;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> s[i];
ma[s[i]] = i;
}
while (m--) {
cin >> a >> b;
u = ma[a];
v = ma[b];
p[u][v] = p[v][u] = true;
}
for (k = 1; k < (1 << n); k++) {
vec.clear();
for (i = 0; i < n; i++)
if (k & (1 << i)) {
vec.push_back(i + 1);
}
if (ok() && vec.size() > ret.size()) {
ret = vec;
}
}
sort(ret.begin(), ret.end(), comp);
cout << ret.size();
for (i = 0; i < ret.size(); i++) cout << '\n' << s[ret[i]];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, vector<string> > graph;
unsigned long long int countSetBits(long long int n) {
unsigned long long int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
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;
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;
const int MOD = 1e9 + 7;
int dX[] = {0, 0, 1, -1};
int dY[] = {1, -1, 0, 0};
int dp[17][1 << 17];
int n, m, team, mx = -1;
map<string, int> mp;
int M[17];
string Name[17];
int popcount(int num) {
int ret = 0;
while (num) ret += (num & 1), num >>= 1;
return ret;
}
void solve(int idx, int mask) {
if (idx == n) {
int op = popcount(mask);
if (op > mx) mx = op, team = mask;
return;
}
if (dp[idx][mask]) return;
dp[idx][mask] = 1;
solve(idx + 1, (mask | 1 << idx) & ~M[idx]);
solve(idx + 1, mask);
return;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
string x, y;
for (int i = 0; i < n; ++i) cin >> x, mp[x] = i, Name[i] = x;
for (int i = 0; i < m; ++i)
cin >> x >> y, M[mp[x]] |= (1 << mp[y]), M[mp[y]] |= (1 << mp[x]);
solve(0, 0);
set<string> ans;
for (int i = 0; i < n; ++i) {
if (team & 1) ans.insert(Name[i]);
team >>= 1;
}
printf("%d\n", mx);
set<string>::iterator it;
for (it = ans.begin(); it != ans.end(); it++) cout << *it << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<string, int> mp;
bool a[20][20];
int res;
int cntt(int p) {
int r = 0;
while (p > 0) {
if (p % 2 == 1) r++;
p /= 2;
}
return r;
}
int main() {
cin >> n >> m;
string s, x;
memset(a, true, sizeof a);
for (int i = 0; i < n; i++) {
cin >> s;
mp.insert(make_pair(s, i));
}
for (int i = 0; i < m; i++) {
cin >> s >> x;
a[mp[s]][mp[x]] = false;
a[mp[x]][mp[s]] = false;
}
res = 0;
for (int i = 0; i < (1 << n); i++) {
bool ck = true;
for (int j = 0; j < n; j++)
if (((i >> j) & 1) == 1)
for (int p = 0; p < n; p++)
if (((i >> p) & 1) == 1) {
if (!a[j][p]) {
ck = false;
break;
}
}
if (ck && cntt(res) < cntt(i)) res = i;
}
int cntt = 0;
for (int i = 0; i < n; i++)
if (((res >> i) & 1) == 1) cntt++;
cout << cntt << endl;
for (map<string, int>::iterator it = mp.begin(); it != mp.end(); it++) {
int j = it->second;
if (((res >> j) & 1) == 1) {
cout << (it->first) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<string, string>> v;
set<string> getTeam(set<string> t, map<string, int> s, string e, int i) {
if (e != "") {
t.erase(t.find(e));
s[e]++;
}
while ((v.begin() + i) != v.end() &&
(s[v[i].first] != 0 || s[v[i].second] != 0))
++i;
if (v.begin() + i == v.end()) return t;
set<string> s1 = getTeam(t, s, v[i].first, i);
set<string> s2 = getTeam(t, s, v[i].second, i);
if (s1.size() >= s2.size()) return s1;
return s2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string x, y;
set<string> se;
map<string, int> ma;
int n, m;
cin >> n >> m;
while (n--) {
cin >> x;
se.insert(x);
ma[x] = 0;
}
while (m--) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
se = getTeam(se, ma, "", 0);
cout << se.size() << "\n";
for (auto i = se.begin(); i != se.end(); ++i) cout << (*i) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, ans = 0;
cin >> n >> m;
string arr[n];
map<string, int> mp;
string s[m][2];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < n; ++i) {
mp[arr[i]] = i;
}
for (int j = 0; j < m; ++j) {
cin >> s[j][0] >> s[j][1];
}
for (int i = 0; i < 1 << n; ++i) {
bool f = 1;
for (int j = 0; j < m; ++j) {
if ((i & (1 << mp[s[j][0]])) && (i & (1 << mp[s[j][1]]))) {
f = 0;
break;
}
}
if (f && __builtin_popcount(i) > __builtin_popcount(ans)) ans = i;
}
cout << __builtin_popcount(ans) << "\n";
for (int i = 0; i < n; ++i) {
if ((1 << i) & ans) cout << arr[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> sub;
int main() {
int n, m;
cin >> n >> m;
string arr[20], frr[150][150];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) cin >> frr[i][0] >> frr[i][1];
int c = 0;
for (int i = 0; i < pow(2, n); i++) {
vector<int> v;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
v.push_back(j);
}
}
int flag = 0;
for (int p = 0; p < v.size(); p++) {
if (flag > 0) break;
for (int q = p + 1; q < v.size(); q++) {
if (flag > 0) break;
for (int l = 0; l < m; l++) {
if (frr[l][0] == arr[v[q]] && frr[l][1] == arr[v[p]]) {
flag++;
break;
} else if (frr[l][1] == arr[v[q]] && frr[l][0] == arr[v[p]]) {
flag++;
break;
}
}
}
}
if (flag == 0) {
if (c < v.size()) {
c = v.size();
sub.clear();
sub = v;
}
}
}
cout << c << endl;
string krr[c + 5];
if (c != 0) {
for (int i = 0; i < c; i++) {
krr[i] = arr[sub[i]];
}
sort(krr, krr + c);
for (int i = 0; i < c; i++) {
cout << krr[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double const EPS = 1e-7;
long long const INF = 1e18;
string s[17];
set<pair<string, string> > noway;
long long popcount(long long mask) {
long long ret = 0;
for (long long i = 0; i < 16; i++) ret += ((mask & (1 << i)) != 0);
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> s[i];
for (long long i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
noway.insert({min(x, y), max(x, y)});
}
long long maxx = 0, maskx = 0;
for (long long mask = 1; mask < (1 << n); mask++) {
vector<string> temp;
for (long long i = 0; i < n; i++)
if (mask & (1 << i)) temp.push_back(s[i]);
bool flag = 1;
for (long long i = 0; i < (long long)temp.size(); i++) {
for (long long j = i + 1; j < (long long)temp.size(); j++)
flag &= (noway.find({min(temp[i], temp[j]), max(temp[i], temp[j])}) ==
noway.end());
}
if (flag) {
if (maxx < popcount(mask)) {
maxx = popcount(mask);
maskx = mask;
}
}
}
cout << maxx << '\n';
vector<string> temp;
for (long long i = 0; i < n; i++)
if (maskx & (1 << i)) temp.push_back(s[i]);
sort(temp.begin(), temp.end());
for (auto x : temp) cout << x << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, n, j, m;
map<string, int> mp;
cin >> n >> m;
string s[n], v[m], u[m];
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < m; i++) cin >> v[i] >> u[i];
sort(s, s + n);
for (i = 0; i < n; i++) mp[s[i]] = i;
int ans = 0;
for (i = 0; i < (1 << n); i++) {
bool f = 1;
for (j = 0; j < m; j++)
if ((i & (1 << mp[v[j]])) && (i & (1 << mp[u[j]]))) f = 0;
if (f && __builtin_popcount(ans) < __builtin_popcount(i)) ans = i;
}
cout << __builtin_popcount(ans) << endl;
for (i = 0; i < n; i++)
if (ans & (1 << i)) cout << s[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, _m, ans = 0;
map<string, int> m;
string s[1010], u[1010], v[1010];
int main() {
cin >> n >> _m;
for (int i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + n + 1);
for (int i = 1; i <= n; i++) m[s[i]] = i - 1;
for (int i = 1; i <= _m; i++) cin >> u[i] >> v[i];
for (int i = 1; i <= (1 << n); i++) {
bool flag = 1;
for (int j = 1; j <= _m; j++)
if (((i - 1) & (1 << m[u[j]])) && ((i - 1) & (1 << m[v[j]]))) flag = 0;
if (flag && __builtin_popcount(ans) < __builtin_popcount(i - 1))
ans = i - 1;
}
cout << __builtin_popcount(ans) << '\n';
for (int i = 1; i <= n; i++)
if (ans & (1 << (i - 1))) cout << s[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mr;
vector<string> v;
string s, s2, tmp, res;
vector<pair<int, int> > e;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
v.push_back(s);
}
sort(v.begin(), v.end());
for (int i = 0; i < m; i++) {
cin >> s >> s2;
int a;
for (a = 0; a < n; a++)
if (v[a] == s) break;
int b;
for (b = 0; b < n; b++)
if (v[b] == s2) break;
e.push_back(make_pair(a, b));
}
int mx = (int)pow(2.0, n);
for (int x = mx - 1; x > 0; x--) {
bool f = true;
for (int i = 0; i < e.size(); i++) {
int e1 = n - e[i].first - 1, e2 = n - e[i].second - 1;
if ((x >> e1 & 1) && (x >> e2 & 1)) f = false;
}
if (f) {
int amx = mx;
int r = 0;
for (int o = 0; o < n; o++) {
if (x & (mx >> 1)) r++;
mx /= 2;
}
mx = amx;
tmp = "";
for (int o = 0; o < n; o++) {
if (x & (mx >> 1)) tmp += v[o] + "\n";
mx /= 2;
}
mx = amx;
if (r > mr) res = tmp, mr = r;
}
}
cout << mr << endl;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = (1e9) + 7;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
inline void fastIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
fastIO();
int n, k, ans = 0;
cin >> n >> k;
map<pair<string, string>, int> has;
vector<string> fin(n);
vector<string> input(n);
for (int i = 0; i < n; i++) {
cin >> input[i];
}
for (int i = 0; i < k; i++) {
string a, b;
cin >> a >> b;
has[make_pair(a, b)] = 1;
has[make_pair(b, a)] = 1;
}
for (int i = 0; i <= pow(2, n); i++) {
bool valid = true;
int cnt = 0;
vector<string> temp;
for (int j = 0; j < n && valid; j++) {
if ((i & (1 << j)) != 0) {
cnt++;
temp.push_back(input[j]);
for (int k = 0; k < n && valid; k++) {
if ((i & (1 << k)) != 0) {
if (has[make_pair(input[k], input[j])]) {
valid = false;
}
}
}
}
}
if (valid && cnt > ans) {
for (int k = 0; k < temp.size(); k++) {
fin[k] = temp[k];
}
ans = cnt;
}
}
cout << ans << endl;
sort(fin.begin(), fin.end());
for (int i = 0; i < fin.size(); i++) {
if (fin[i] != "") {
cout << fin[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long int modPow(long long int base, long long int exp,
long long int modulus) {
base %= modulus;
long long int result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
inline string NumToStr(long long int Number) {
stringstream ss;
ss << Number;
return ss.str();
}
inline long long int StrToNum(const string &Text) {
stringstream ss(Text);
long long int result;
return ss >> result ? result : 0;
}
inline long long int maximum(long long int a, long long int b,
long long int c) {
long long int d = (a >= b) ? a : b;
long long int e = (d >= c) ? d : c;
return e;
}
int main() {
ios_base::sync_with_stdio(0);
;
cin.tie(0);
map<string, int> name;
map<int, string> ulta;
long long int n, m;
cin >> n >> m;
string s, str;
for (long long int i = 0; i < n; i++) {
cin >> s;
name[s] = i;
ulta[i] = s;
}
bool bad[n][n];
for (long long int i = 0; i < n; i++)
for (long long int j = 0; j < n; j++) bad[i][j] = 1;
for (long long int i = 0; i < m; i++) {
cin >> s >> str;
bad[name[s]][name[str]] = 0;
bad[name[str]][name[s]] = 0;
}
long long int mask = pow(2, n);
long long int val = 1, ival = 1;
for (long long int i = 1; i < mask; i++) {
vector<long long int> team;
for (long long int j = 0; j < n; j++) {
if (i & (1 << j)) {
team.push_back(j);
}
}
bool ha = true;
for (long long int j = 0; j < team.size(); j++) {
for (long long int k = 0; k < team.size(); k++) {
if (bad[team[j]][team[k]] == 0) {
ha = false;
break;
}
}
}
if (ha) {
if (__builtin_popcount(i) > val) {
val = __builtin_popcount(i);
ival = i;
}
}
}
vector<string> ss;
cout << val << endl;
for (long long int i = 0; i < n; i++) {
if (ival & (1 << i)) {
ss.push_back(ulta[i]);
}
}
sort(ss.begin(), ss.end());
for (long long int i = 0; i < ss.size(); i++) cout << ss[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, 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) {
ok = true;
for (int j = 0; j < n and ok; ++j)
if (i & (1 << j))
for (int &k : notgood[j])
if (i & (1 << k)) {
ok = false;
break;
}
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;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t, n, i, m, j, r;
cin >> n >> m;
map<string, int> make_pair;
map<int, string> mp2;
string s, s2;
for (i = 0; i < n; i++) {
cin >> s;
make_pair.insert({s, i});
mp2.insert({i, s});
}
vector<pair<int, int> > v;
vector<string> res;
for (i = 0; i < m; i++) {
cin >> s >> s2;
v.push_back({make_pair[s], make_pair[s2]});
}
int cnt = 0, ans = 0;
for (i = 0; i < (1 << (n + 1)); i++) {
cnt = 0;
for (j = 0; j < v.size(); j++) {
if (((i >> (v[j].first)) & 1) == 1 && ((i >> (v[j].second)) & 1) == 1) {
cnt = -1;
break;
}
}
if (cnt == -1) continue;
for (j = 0; j < n; j++) {
if (((i >> j) & 1) == 1) cnt++;
}
if (cnt > ans) {
ans = cnt;
r = i;
}
}
for (i = 0; i < n; i++)
if (((r >> i) & 1) == 1) res.push_back(mp2[i]);
sort(res.begin(), res.end());
cout << res.size() << endl;
for (i = 0; i < res.size(); i++) cout << res[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
char name[18][15];
pair<string, string> p[125];
for (int i = 0; i < n; i++) scanf("%s", name[i]);
for (int i = 0; i < m; i++) {
char s1[15];
char s2[15];
scanf("%s%s", &s1, &s2);
p[i] = {(string)s1, (string)s2};
}
vector<string> res;
for (int i = 0; i < (1 << n); i++) {
int ii = i;
int cnt = 0;
vector<string> v;
while (ii) {
if (ii & 1) v.push_back((string)name[cnt]);
cnt++;
ii = ii >> 1;
}
bool f = 1;
for (int j = 0; j < v.size() && f; j++)
for (int k = 0; k < v.size() && f; k++)
for (int z = 0; z < m; z++)
if (p[z].first == v[j] && p[z].second == v[k]) {
f = 0;
break;
}
if (!f) continue;
if (v.size() > res.size()) res = v;
}
sort(res.begin(), res.end());
printf("%d\n", res.size());
for (int i = 0; i < res.size(); i++) printf("%s\n", res[i].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> dict;
char name[20][200];
bool mat[20][20];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
dict.clear();
for (int i = 0; i < n; i++) {
char buf[200];
scanf("%s", name[i]);
dict[name[i]] = i;
}
memset(mat, 0, sizeof(mat));
for (int i = 0; i < m; i++) {
char b1[200], b2[200];
scanf("%s%s", b1, b2);
mat[dict[b1]][dict[b2]] = true;
}
int res = 0;
int max = 0;
for (int i = 0; i < (1 << n); i++) {
bool can = true;
for (int s = 0; s < n; s++)
for (int t = 0; t < n; t++)
if (mat[s][t]) {
if (((1 << s) & i) && ((1 << t) & i)) can = false;
}
if (can) {
int c = 0;
for (int s = 0; s < n; s++) {
if ((1 << s) & i) c++;
}
if (c > max) {
max = c;
res = i;
}
}
}
vector<string> gao;
for (int s = 0; s < n; s++) {
if ((1 << s) & res) {
gao.push_back(name[s]);
}
}
sort(gao.begin(), gao.end());
printf("%d\n", max);
for (int i = 0; i < max; i++) puts(gao[i].c_str());
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> res;
vector<int> tmp;
map<string, int> idx;
string Name[17];
int a[17][17];
int n, m;
void Read_Input() {
string x, y;
int u, v;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
cin >> x;
Name[i] = x;
}
sort(Name + 1, Name + 1 + n);
for (int i = 1; i <= n; i++) idx[Name[i]] = i;
for (int i = 0; i < m; i++) {
cin >> x >> y;
u = idx[x];
v = idx[y];
a[u][v] = a[v][u] = 1;
}
}
void Try(int k) {
if (tmp.size() > res.size()) {
res = tmp;
}
if (k > n) return;
bool ok = true;
for (int i = 0; i < tmp.size(); i++)
if (a[tmp[i]][k]) {
ok = false;
break;
}
if (ok) {
tmp.push_back(k);
Try(k + 1);
tmp.pop_back();
}
Try(k + 1);
}
void Solve() { Try(1); }
void Write_Output() {
printf("%d\n", res.size());
for (int i = 0; i < res.size(); i++) cout << Name[res[i]] << endl;
}
int main() {
Read_Input();
Solve();
Write_Output();
}
|
#include <bits/stdc++.h>
using namespace std;
void lo_ol() {
int n, m;
cin >> n >> m;
int mask = -1, len = 0;
string names[n + 1];
map<string, int> mp;
for (int i = 0; i < n; i++) {
cin >> names[i];
mp[names[i]] = i;
}
pair<int, int> A[m];
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
A[i] = {mp[a], mp[b]};
}
for (int i = 0; i < (1 << n); i++) {
int bits = 0;
for (auto j : A) {
if ((i & (1 << j.first)) and (i & (1 << j.second))) goto end;
}
for (int j = 0; j < n; j++) {
if (i & (1 << j)) bits++;
}
if (bits > len) {
len = bits;
mask = i;
}
end:;
}
set<string> s;
for (int j = 0; j < n; j++) {
if (mask & (1 << j)) s.insert(names[j]);
}
cout << s.size() << endl;
for (const auto &i : s) cout << i << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int test = 1;
while (test--) {
lo_ol();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
string name[100];
int bad[16] = {};
vector<string> ans;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> name[i];
sort(name, name + n);
for (int i = 0; i < m; i++) {
string u, v;
cin >> u >> v;
int iu = find(name, name + n, u) - name;
int iv = find(name, name + n, v) - name;
bad[iu] |= 1 << iv;
bad[iv] |= 1 << iu;
}
for (int s = 0; s < (1 << n); s++) {
int B = 0;
vector<string> tmp;
for (int i = 0; i < n; i++)
if (s & (1 << i)) {
B |= bad[i];
tmp.push_back(name[i]);
}
if (!(s & B)) {
if (ans.size() < tmp.size()) ans = tmp;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<string>> result;
void findSubsets(vector<string>& x, int index, vector<string>& combination) {
if (index == x.size()) {
result.push_back(combination);
return;
}
combination.push_back(x[index]);
findSubsets(x, index + 1, combination);
combination.pop_back();
findSubsets(x, index + 1, combination);
}
bool compare(vector<string> v1, vector<string> v2) {
return v1.size() > v2.size();
}
int main() {
int n, m;
cin >> n >> m;
vector<string> x, c;
pair<string, string> arr[m];
for (int i = 0; i < n; i++) {
string str;
cin >> str;
x.push_back(str);
}
for (int i = 0; i < m; i++) {
cin >> arr[i].first >> arr[i].second;
}
findSubsets(x, 0, c);
sort(result.begin(), result.end(), compare);
vector<string> ans;
for (int i = 0; i < result.size(); i++) {
bool flag = true;
sort(result[i].begin(), result[i].end());
for (int j = 0; j < m; j++) {
std::vector<string>::iterator it1, it2;
it1 = std::find(result[i].begin(), result[i].end(), arr[j].first);
it2 = std::find(result[i].begin(), result[i].end(), arr[j].second);
if (it1 != result[i].end() && it2 != result[i].end()) {
flag = false;
}
}
if (flag) {
ans = result[i];
break;
}
}
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;
const int N = 20;
string s[N];
string anss[N];
struct ff {
int x, y;
} mm[N * N];
int f(int x) {
int ans = 0;
while (x) {
if (x & 1) ans++;
x >>= 1;
}
return ans;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> s[i];
string a, b;
int tt = 0;
for (int i = 0; i < m; i++) {
cin >> a >> b;
int q, w;
for (int j = 0; j < n; j++) {
if (a == s[j]) q = j;
if (b == s[j]) w = j;
}
mm[tt].x = q;
mm[tt++].y = w;
}
int ans = 0, ss;
for (int i = (1 << n) - 1; i >= 0; i--) {
int ret = f(i);
int ok = 1;
for (int j = 0; j < tt; j++) {
if ((1 << mm[j].x) & i) {
if ((1 << mm[j].y) & i) {
ok = 0;
break;
}
}
}
if (ok && ret > ans) {
ans = ret;
ss = i;
}
}
printf("%d\n", ans);
int t = 0;
for (int i = 0; i < n; i++) {
if ((1 << i) & ss) {
anss[t++] = s[i];
}
}
sort(anss, anss + t);
for (int i = 0; i < t; i++) {
cout << anss[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
int n, m;
string name[N];
int a[N][N];
int GetCount(int k) {
int i = 0;
while (k > 0) {
i += k % 2;
k /= 2;
}
return i;
}
int main() {
int i, ans, j, k, maxres;
int nA, nB;
char szName[32] = {0};
char szA[32] = {0};
char szB[32] = {0};
while (scanf("%d%d", &n, &m) == 2) {
for (i = 0; i < n; ++i) {
scanf("%s", szName);
name[i] = szName;
}
sort(name, name + n);
memset(a, 0, sizeof(a));
for (i = 0; i < m; ++i) {
scanf("%s%s", szA, szB);
for (j = 0; j < n; ++j) {
if (strcmp(name[j].c_str(), szA) == 0) nA = j;
if (strcmp(name[j].c_str(), szB) == 0) nB = j;
}
a[nA][nB] = a[nB][nA] = 1;
}
maxres = 0;
for (ans = 1; ans < (1 << n); ++ans) {
bool ok = true;
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) {
nA = (1 << i) & ans;
nB = (1 << j) & ans;
if (nA == 0 || nB == 0) continue;
if (a[i][j] > 0) ok = false;
}
if (!ok) continue;
if (GetCount(ans) > GetCount(maxres)) maxres = ans;
}
int res[16];
ans = 0;
for (i = 0; i < n; ++i)
if ((maxres & (1 << i)) > 0) res[ans++] = i;
printf("%d\n", ans);
for (i = 0; i < ans; ++i) printf("%s\n", name[res[i]].c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans = 0;
map<string, int> mp;
vector<string> names;
pair<vector<string>, int> Solve(int i, vector<int> g[], int v[]) {
if (i == n) return make_pair(vector<string>(), 0);
pair<vector<string>, int> maxN = Solve(i + 1, g, v);
if (!v[i]) {
for (int j = 0; j < g[i].size(); j++) v[g[i][j]]++;
pair<vector<string>, int> temp = Solve(i + 1, g, v);
temp.first.push_back(names[i]);
temp.second++;
if (temp.second > maxN.second) maxN = temp;
for (int j = 0; j < g[i].size(); j++) v[g[i][j]]--;
}
return maxN;
}
int main() {
cin >> n >> m;
vector<int> g[n];
string s, a, b;
for (int i = 0; i < n; i++) {
cin >> s;
names.push_back(s);
mp[s] = i;
}
for (int i = 0; i < m; i++) {
cin >> a >> b;
g[mp[a]].push_back(mp[b]);
g[mp[b]].push_back(mp[a]);
}
int v[n];
memset(v, 0, sizeof v);
pair<vector<string>, int> p = Solve(0, g, v);
cout << p.second << endl;
sort(p.first.begin(), p.first.end());
for (int i = 0; i < p.first.size(); i++) cout << p.first[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
inline long long MAX2(long long a, long long b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
int mod = 1e9 + 7;
int64_t extGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
if (!a) {
x = 0;
y = 1;
return b;
}
int64_t x1, y1;
int64_t d = extGcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
inline long long addmod(long long a, long long b) {
a = a % mod + b % mod;
if (a > mod) a %= mod;
return a;
}
inline long long submod(long long a, long long b) {
a = a % mod - b % mod;
if (a < 0) a += mod;
return a;
}
inline long long mulmod(long long a, long long b) {
return (a % mod * b % mod) % mod;
}
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
inline long long exp(long long a, long long b) {
if (a == 0) return 0ll;
long long r = 1LL;
while (b > 0) {
if (b & 1) {
r = r * (a % mod);
r = (r + mod) % mod;
}
b /= 2;
a = (a % mod) * (a % mod);
a = (a + mod) % mod;
}
return (r + mod) % mod;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
if (a == 0) return b;
return gcd(b, a % b);
}
unsigned long int setbits(long long n) {
unsigned long int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int main() {
if (fopen("input.txt", "r"))
freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
;
int n, m;
cin >> n >> m;
map<string, int> m1;
map<int, string> m2;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m1[s] = i;
m2[i] = s;
}
map<pair<int, int>, int> enemy;
for (int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
enemy[make_pair(m1[s1], m1[s2])]++;
enemy[make_pair(m1[s2], m1[s1])]++;
}
vector<string> g1;
int temp = 0;
vector<string> curr_taken;
for (long long i = 1; i <= (1LL << n); i++) {
int cnt = 0;
int j = i;
while (j > 0) {
if (j & 1) curr_taken.push_back(m2[cnt]);
cnt++;
j = j / 2;
}
bool isvalid = true;
for (int x = 0; x < curr_taken.size(); x++) {
for (int k = x + 1; k < curr_taken.size(); k++) {
if (enemy[(make_pair(m1[curr_taken[x]], m1[curr_taken[k]]))]) {
isvalid = false;
break;
}
}
}
if (isvalid) {
if (curr_taken.size() > g1.size()) {
g1.clear();
for (auto x : curr_taken) g1.push_back(x);
}
}
curr_taken.clear();
}
cout << g1.size() << '\n';
sort(g1.begin(), g1.end());
for (auto x : g1) cout << x << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> m1;
map<int, string> m2;
vector<pair<int, int>> pairs;
vector<string> names;
int main() {
int n, m, max = 0, sol = 0;
string name, name2;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> name;
names.push_back(name);
}
sort(names.begin(), names.end());
for (int i = 0; i < n; i++) {
m1[names[i]] = i;
}
for (int i = 0; i < m; i++) {
cin >> name >> name2;
pairs.push_back(make_pair(m1[name], m1[name2]));
}
for (int i = 0; i < (1 << n); i++) {
bool pos = true;
for (int j = 0; j < m; j++) {
if ((i & (1 << pairs[j].first)) && (i & (1 << pairs[j].second))) {
pos = false;
break;
}
}
if (pos && __builtin_popcount(i) > max) {
max = __builtin_popcount(i);
sol = i;
}
}
if (m != 0)
cout << max << endl;
else {
cout << n << endl;
for (int i = 0; i < n; i++) {
cout << names[i] << endl;
}
return 0;
}
for (int i = 0; i < n; i++) {
if (sol & (1 << i)) cout << names[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> dict;
bool buf[16][16] = {};
vector<int> ans;
int main(void) {
int n, m;
cin >> n >> m;
vector<string> name(n);
for (int i = 0; i < (n); ++i) {
string s;
cin >> s;
dict[s] = i;
name[i] = s;
}
for (int i = 0; i < (m); ++i) {
string _a, _b;
cin >> _a >> _b;
int a = dict[_a], b = dict[_b];
buf[a][b] = buf[b][a] = true;
}
for (int c = 0; c < ((1 << n)); ++c) {
vector<int> res;
for (int i = 0; i < (n); ++i)
if (c & (1 << i)) res.push_back(i);
bool tag = true;
for (int i = 0; i < (res.size()); ++i)
for (int j = 0; j < (res.size()); ++j)
if (buf[res[i]][res[j]]) tag = false;
if (tag && res.size() > ans.size()) ans = res;
}
cout << ans.size() << endl;
vector<string> pt(ans.size());
for (int i = 0; i < (ans.size()); ++i) pt[i] = name[ans[i]];
sort(pt.begin(), pt.end());
for (int i = 0; i < (pt.size()); ++i) cout << pt[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<string> > subset(vector<string> &s) {
vector<vector<string> > vi;
int n = s.size();
int num = 1 << n;
int a[n + 1];
for (int i = 1; i <= num; i++) {
int j = i;
int m = n - 1;
memset(a, 0, sizeof(a));
while (j > 0) {
int x = j & 1;
j >>= 1;
a[m] = x;
m--;
}
vector<string> vo;
for (int k = 0; k < n; k++) {
if (a[k] == 1) {
vo.push_back(s[k]);
}
}
if (vo.size() > 0) vi.push_back(vo);
}
return vi;
}
void disp(vector<string> &v) {
cout << v.size() << " ";
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << "\n";
}
int main() {
int n, m;
cin >> n >> m;
vector<string> v;
set<pair<string, string> > se;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
se.insert(make_pair(s1, s2));
se.insert(make_pair(s2, s1));
}
vector<vector<string> > vo = subset(v);
vector<string> ma;
int mai = -1;
bool f = true;
for (int i = 0; i < vo.size(); i++) {
vector<string> to = vo[i];
f = true;
for (int j = 0; j < to.size() && f; j++) {
for (int k = j + 1; k < to.size() && f; k++) {
if (se.find(make_pair(to[j], to[k])) != se.end()) {
f = false;
}
}
}
int y = to.size();
if (f && (y > mai)) {
mai = to.size();
ma = to;
sort(ma.begin(), ma.end());
}
}
cout << mai << "\n";
for (int i = 0; i < ma.size(); i++) {
cout << ma[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> func(vector<string> &v, vector<pair<string, string>> vg,
vector<string>::iterator it) {
if (it != v.end()) v.erase(it);
vector<string> a = v;
vector<string> b = v;
for (int i = 0; i < vg.size(); i++) {
auto it = find(a.begin(), a.end(), vg[i].first);
auto it1 = find(b.begin(), b.end(), vg[i].second);
if ((it != a.end()) and (it1 != b.end())) {
a = func(a, vg, it);
b = func(b, vg, it1);
if (a.size() >= b.size()) {
v = a;
} else
v = b;
break;
}
}
sort(v.begin(), v.end());
return v;
}
void func(vector<string> &v, vector<pair<string, string>> vg) {
vector<string> a = v;
vector<string> b = v;
for (int i = 0; i < vg.size(); i++) {
auto it = find(a.begin(), a.end(), vg[i].first);
auto it1 = find(b.begin(), b.end(), vg[i].second);
if ((it != a.end()) and (it1 != b.end())) {
a = func(a, vg, it);
b = func(b, vg, it1);
if (a.size() >= b.size()) {
v = a;
} else
v = b;
break;
}
}
sort(v.begin(), v.end());
}
int main() {
int n, m;
string t, a, b;
vector<string> v;
vector<pair<string, string>> dg;
cin >> n;
cin >> m;
for (int i = 0; i < n; i++) {
cin >> t;
v.push_back(t);
}
for (int i = 0; i < m; i++) {
cin >> a;
cin >> b;
pair<string, string> p(a, b);
dg.push_back(p);
}
func(v, dg, v.end());
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> dic(n);
map<string, int> M;
vector<set<int> > g(n);
for (int i = 0; i < n; i++) cin >> dic[i], M[dic[i]] = i;
for (int i = 0; i < m; i++) {
string s, t;
cin >> s >> t;
g[M[s]].insert(M[t]);
g[M[t]].insert(M[s]);
}
vector<int> best;
vector<string> res;
for (int mask = 0; mask < (1 << n); mask++) {
bool t = true;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (((mask >> i) & 1) && ((mask >> j) & 1)) {
if (g[i].count(j)) {
t = false;
goto sale;
}
}
}
}
sale:
if (t) {
vector<int> tmp;
for (int i = 0; i < n; i++) {
if ((mask >> i) & 1) {
tmp.push_back(i);
}
}
if (tmp.size() > best.size()) {
best = tmp;
}
}
}
for (int i = 0; i < best.size(); i++) res.push_back(dic[best[i]]);
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
int n, m;
bool can[N][N];
unordered_map<string, int> id;
string names[N];
bool can_match(const vector<string>& ns) {
for (int i = 0; i < ns.size(); i++) {
for (int j = i + 1; j < ns.size(); j++) {
if (!can[id[ns[i]]][id[ns[j]]]) {
return false;
}
}
}
return true;
}
int main(int argc, char** argv) {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> names[i];
id[names[i]] = i;
}
memset(can, true, sizeof(can));
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
can[id[a]][id[b]] = false;
can[id[b]][id[a]] = false;
}
set<string> result;
int mx_size = numeric_limits<int>::min();
for (int mask = 0; mask < 1 << n; mask++) {
vector<string> team;
for (int i = 0; i < n; i++) {
if (!(mask & (1 << i))) continue;
team.push_back(names[i]);
}
if (can_match(team) && (int)team.size() > mx_size) {
mx_size = team.size();
result = set<string>(team.begin(), team.end());
}
}
cout << result.size() << endl;
for (string name : result) {
cout << name << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class names {
public:
string name;
};
bool operator<(names a, names b) {
if (a.name != b.name) {
return lexicographical_compare(a.name.begin(), a.name.end(), b.name.begin(),
b.name.end());
}
return false;
}
map<int, string> mm;
void printResult(vector<int>& v) {
vector<names> n;
for (int i = 0; i < v.size(); i++) {
names cur;
cur.name = mm[v[i]];
n.push_back(cur);
}
sort(n.begin(), n.end());
cout << n.size() << endl;
for (int i = 0; i < n.size(); i++) {
cout << n[i].name << endl;
}
}
int main() {
int N, M;
cin >> N >> M;
map<string, int> m;
string name = "";
for (int i = 0; i < N; i++) {
cin >> name;
m[name] = i;
mm[i] = name;
}
string a = "";
string b = "";
set<pair<int, int> > s;
for (int i = 0; i < M; i++) {
cin >> a >> b;
int ind_a = m[a];
int ind_b = m[b];
pair<int, int> p;
p.first = min(ind_a, ind_b);
p.second = max(ind_a, ind_b);
s.insert(p);
}
int maxP = 0;
vector<int> maxM;
for (int i = 0; i < (1 << N); i++) {
vector<int> tmp;
for (int j = 0; j < N; j++) {
if (i & (1 << j)) {
tmp.push_back(j);
}
}
if ((int)tmp.size() <= maxP) continue;
bool found = true;
for (int k = 0; k < tmp.size() - 1; k++) {
for (int l = k + 1; l < tmp.size(); l++) {
pair<int, int> p;
p.first = tmp[k];
p.second = tmp[l];
if (s.count(p)) {
found = false;
break;
}
}
}
if (found) {
maxP = tmp.size();
maxM = tmp;
}
}
printResult(maxM);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> result;
vector<string> names;
map<string, unordered_set<string> > graph;
void printVector(vector<string> v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << endl;
}
}
bool isConflicting(int j, vector<string> sofar) {
for (int i = 0; i < sofar.size(); i++) {
string u = sofar[i];
string v = names[j];
if (graph[u].find(v) != graph[u].end()) {
return true;
}
}
return false;
}
void generateSets(vector<string> sofar, int j) {
if (j == n) {
if (sofar.size() > result.size()) {
result = sofar;
}
return;
}
vector<string> tmp = sofar;
tmp.push_back(names[j]);
if (!isConflicting(j, sofar)) generateSets(tmp, j + 1);
generateSets(sofar, j + 1);
}
int main() {
cin >> n >> m;
names.resize(n);
for (int i = 0; i < n; ++i) {
cin >> names[i];
unordered_set<string> tmp;
graph[names[i]] = tmp;
}
for (int i = 0; i < m; ++i) {
string u, v;
cin >> u >> v;
graph[u].insert(v);
graph[v].insert(u);
}
vector<string> sofar;
generateSets(sofar, 0);
sort(result.begin(), result.end());
printVector(result);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string mas[17], xxx[2][200], ans[17], ans1[17];
int n, m, len = 0;
void perebor(int step, int l) {
if (step == n) {
if (l > len) {
len = l;
for (int i = 0; i < l; i++) ans[i] = ans1[i];
}
} else {
perebor(step + 1, l);
bool b = true;
for (int i = 0; i < l && b; i++)
for (int j = 0; j < m && b; j++) {
if ((xxx[0][j] == mas[step] && xxx[1][j] == ans1[i]) ||
(xxx[1][j] == mas[step] && xxx[0][j] == ans1[i]))
b = false;
}
if (b) {
ans1[l] = mas[step];
perebor(step + 1, l + 1);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> mas[i];
for (int i = 0; i < m; i++) cin >> xxx[0][i] >> xxx[1][i];
perebor(0, 0);
cout << len << endl;
sort(ans, ans + len);
for (int i = 0; i < len; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 2000000000000000003;
const int maxn = 1e5 + 9;
const int MAXN = 1000 + 5;
using namespace std;
int in() {
char c = getchar();
int t = 0;
while (c < '0' || c > '9') {
c = getchar();
}
while (c >= '0' && c <= '9') {
t = t * 10 + c - '0';
c = getchar();
}
return t;
}
int n, m;
string s[maxn];
set<string> ans, res;
pair<string, string> p[maxn];
bool ch() {
for (int i = 0; i < m; i++) {
if (ans.find(p[i].first) != ans.end() && ans.find(p[i].second) != ans.end())
return 0;
}
return 1;
}
void dfs(int i) {
if (i == n) {
if (ch()) {
if (ans.size() > res.size()) {
res = ans;
}
}
return;
}
ans.insert(s[i]);
dfs(i + 1);
ans.erase(s[i]);
dfs(i + 1);
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n >> m) {
ans.clear();
res.clear();
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
}
dfs(0);
cout << res.size() << endl;
for (set<string>::iterator it = res.begin(); it != res.end(); it++) {
cout << *it << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool mark[20][20] = {0};
vector<string> v;
map<string, int> m;
vector<int> maxv;
int maxi, n;
void f(vector<int> v1, int ind) {
if (ind == n) {
int sz = v1.size(), i, j;
for (i = 0; i < sz; i++) {
for (j = i + 1; j < sz; j++) {
if (mark[v1[i]][v1[j]]) {
return;
}
}
}
if (sz > maxi) {
maxi = sz;
maxv = v1;
}
return;
}
f(v1, ind + 1);
v1.push_back(ind);
f(v1, ind + 1);
}
int main() {
int r, i;
char a[1000], b[1000];
scanf("%d", &n);
scanf("%d", &r);
for (i = 0; i < n; ++i) {
scanf("%s", a);
m[a] = i;
v.push_back(a);
}
for (i = 0; i < r; ++i) {
scanf("%s", a);
scanf("%s", b);
mark[m[a]][m[b]] = 1;
mark[m[b]][m[a]] = 1;
}
maxi = -1;
vector<int> v1;
f(v1, 1);
v1.push_back(0);
f(v1, 1);
vector<string> print;
int sz = maxv.size();
for (i = 0; i < sz; ++i) {
print.push_back(v[maxv[i]]);
}
sort(print.begin(), print.end());
printf("%d\n", sz);
for (i = 0; i < sz; ++i) printf("%s\n", print[i].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<string, int> nums;
vector<string> names;
vector<string> ans;
int dl[20][20];
int maxx;
int maxnum;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
string str;
cin >> str;
nums[str] = i;
names.push_back(str);
}
for (int i = 0; i < m; i++) {
string str1, str2;
cin >> str1 >> str2;
dl[nums[str1]][nums[str2]] = dl[nums[str2]][nums[str1]] = 1;
}
int fail = 0;
for (int i = 0; i < (1 << n); i++) {
fail = 0;
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if ((i & (1 << j)) && (i & (1 << k)) && dl[j][k] == 1) fail = 1;
}
}
if (!fail) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) sum++;
}
if (sum > maxx) {
maxx = sum;
maxnum = i;
}
}
}
printf("%d\n", maxx);
for (int i = 0; i < n; i++) {
if (maxnum & (1 << i)) ans.push_back(names[i]);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int viss[20], xx[20][20], i, j, k, n, m, t, tt, f, x, ans, sum;
string s[20], a, b;
map<string, int> vis;
vector<int> q;
vector<string> ss;
q.clear();
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> s[i];
vis[s[i]] = i;
}
memset(xx, 0, sizeof(xx));
for (i = 0; i < m; i++) {
cin >> a >> b;
xx[vis[a]][vis[b]] = 1;
xx[vis[b]][vis[a]] = 1;
}
for (sum = ans = 0, i = 1; i < (1 << n); i++) {
x = i;
q.clear();
for (j = 0; j < n; j++) {
if ((x >> j) & 1) {
q.push_back(j + 1);
}
}
for (f = j = 0; j < q.size(); j++) {
for (k = j + 1; k < q.size(); k++) {
if (xx[q[j]][q[k]]) {
f = 1;
break;
}
}
if (f) break;
}
if (f == 0 && ans < q.size()) {
ans = q.size();
sum = i;
}
}
q.clear();
for (i = 0; i < n; i++) {
if ((sum >> i) & 1) {
ss.push_back(s[i + 1]);
}
}
cout << ss.size() << endl;
sort(ss.begin(), ss.end());
for (i = 0; i < ss.size(); i++) {
cout << ss[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 18;
const int MSK = 1 << N;
int dp[MSK];
int best[MSK];
int n, m;
char str[N], a[N], b[N];
string s[N];
map<string, int> nametoid;
vector<int> adj[N];
vector<string> ans;
int solve(int msk = 0, int take = 0) {
if (take == n) return 0;
int &ret = dp[msk];
if (~ret) return ret;
ret = 0;
for (int i = 0; i < int(n); i++) {
if (msk & (1 << i)) continue;
int cnt = 1;
int add = (1 << i);
for (int nxt : adj[i]) {
if (msk & (1 << nxt)) continue;
add |= (1 << nxt);
cnt++;
}
if (ret < solve(msk | add, take + cnt) + 1) {
ret = solve(msk | add, take + cnt) + 1;
best[msk] = i;
}
}
return ret;
}
void construct(int msk = 0, int take = 0) {
if (take == n) return;
int r = 0;
for (int i = 0; i < int(n); i++) {
if (msk & (1 << i)) continue;
int cnt = 1;
int add = (1 << i);
for (int nxt : adj[i]) {
if (msk & (1 << nxt)) continue;
add |= (1 << nxt);
cnt++;
}
if (dp[msk] == solve(msk | add, take + cnt) + 1) {
ans.push_back(s[i]);
construct(msk | add, take + cnt);
return;
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < int(n); i++) {
scanf("%s", str);
s[i] = string(str);
nametoid[s[i]] = i;
}
for (int i = 0; i < int(m); i++) {
scanf("%s%s", a, b);
adj[nametoid[string(a)]].push_back(nametoid[string(b)]);
adj[nametoid[string(b)]].push_back(nametoid[string(a)]);
}
memset(dp, -1, sizeof dp);
memset(best, -1, sizeof dp);
printf("%d\n", solve());
construct();
sort(ans.begin(), ans.end());
for (int i = 0; i < int(int(ans.size())); i++) printf("%s\n", ans[i].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char name1[128], name2[128];
map<string, int> m1;
map<int, string> m2;
bool adj[32][32];
bool visited[32];
vector<int> res;
vector<int> resg;
bool cmp(int a, int b) { return m2[a] < m2[b]; }
int run(int u) {
if (u == n) {
if (res.size() > resg.size()) resg = res;
return 0;
}
int op1 = run(u + 1);
bool fail = false;
for (int i = 0; i < (int)res.size(); i++)
if (adj[res[i]][u]) fail = true;
int op2 = 0;
if (!fail) {
res.push_back(u);
op2 = 1 + run(u + 1);
res.pop_back();
}
return max(op1, op2);
}
int main() {
m1.clear();
m2.clear();
memset(adj, false, sizeof(adj));
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", name1);
string n1 = name1;
m1[n1] = i;
m2[i] = n1;
}
for (int i = 0; i < m; i++) {
scanf("%s %s", name1, name2);
string n1 = name1;
string n2 = name2;
adj[m1[n1]][m1[n2]] = true;
adj[m1[n2]][m1[n1]] = true;
}
memset(visited, false, sizeof(visited));
res.clear();
printf("%d\n", run(0));
sort(resg.begin(), resg.end(), cmp);
for (int i = 0; i < (int)resg.size(); i++)
printf("%s\n", m2[resg[i]].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int a[N][N], n, m, gh, mx = -1e9;
string s, aba, t, s1[N];
map<string, int> mp;
vector<string> ans;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> aba;
mp[aba] = i;
s1[i] = aba;
}
for (int i = 0; i < m; i++) {
string hh;
cin >> aba >> hh;
a[mp[aba]][mp[hh]] = a[mp[hh]][mp[aba]] = 1;
}
for (int i = 0; i < (1 << n); i++) {
bool ch = 0;
int cnt = 0;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) {
for (int k = 0; k < n; k++)
if ((i >> k) & 1) ch = ch | a[j][k];
cnt++;
}
if (!ch && cnt > mx) gh = i, mx = cnt;
}
for (int i = 0; i < n; i++)
if ((gh >> i) & 1) ans.push_back(s1[i]);
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct MyPair {
string name1, name2;
};
bool foundConflict(int n, int m, string AllNames[], struct MyPair pairs[],
uint64_t selected) {
for (int i = 0; i < n; i++) {
if (selected & (1 << i)) {
for (int j = 0; j < i; j++) {
if (selected & (1 << j)) {
for (int u = 0; u < m; u++) {
if (AllNames[i].compare(pairs[u].name1) == 0 &&
AllNames[j].compare(pairs[u].name2) == 0)
return true;
else if (AllNames[i].compare(pairs[u].name2) == 0 &&
AllNames[j].compare(pairs[u].name1) == 0)
return true;
}
}
}
}
}
return false;
}
int popCount(uint64_t x) {
int counter;
for (counter = 0; x; counter++) x &= x - 1;
return counter;
}
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d %d", &n, &m);
string AllNames[n];
struct MyPair pairs[m];
int ntmp = n, mtmp = m;
while (ntmp--) {
cin >> AllNames[ntmp];
}
while (mtmp--) {
cin >> pairs[mtmp].name1 >> pairs[mtmp].name2;
}
int size = sizeof(AllNames) / sizeof(AllNames[0]);
sort(AllNames, AllNames + size);
uint64_t finalSelection = 0, i;
for (i = 1; i < (1 << n); i++) {
if (!foundConflict(n, m, AllNames, pairs, i)) {
if (popCount(i) > popCount(finalSelection)) {
if (i > finalSelection) {
finalSelection = i;
}
}
}
}
printf("%d\n", popCount(finalSelection));
for (int i = 0; i < n; ++i) {
if (finalSelection & (1 << i)) cout << AllNames[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653689793238460;
const long long inf = 0x3f3f3f3f3f3f;
const int N = 2e5 + 5;
const int pr = 31;
using ld = long double;
int mod = 1e9 + 7;
long long gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(int a, int b) { return (a / gcd(a, b)) * b; }
int fact(int n) {
int res = 1;
for (int i = 2; i <= n; i++) res = res * i % mod;
return res % mod;
}
int ncr(int n, int r) { return fact(n) / (fact(r) * fact(n - r)); }
int power(long long x, unsigned int y, int p) {
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long nCr(long long n, long long k) {
long long C[105][1005];
long long i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]);
}
}
return C[n][k];
}
unsigned int setbit(long long n) {
unsigned long long count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int sub(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return i;
}
return -1;
}
unsigned P2(unsigned x) {
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
long long phi(long long n) {
long long result = n;
for (long long i = 2; (long long)i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
}
if (n > 1) {
result -= result / n;
}
return result;
}
string s[10005];
map<int, string> m1;
map<string, int> m2;
bool hate[105][105];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)n; i++) {
cin >> s[i];
m2[s[i]] = i;
m1[i] = s[i];
}
for (int i = 0; i < (int)m; i++) {
string s, s2;
cin >> s >> s2;
hate[m2[s]][m2[s2]] = true;
hate[m2[s2]][m2[s]] = true;
}
int ans = 0;
int cnf;
for (int i = 0; i < (int)(1 << n); i++) {
bool ok = true;
int cc = 0;
for (int j = 0; j < (int)n; j++) {
if ((1 << j) & i) cc++;
for (int k = 0; k < (int)n; k++) {
if (((1 << j) & i) != 0 && ((1 << k) & i) != 0 && hate[j][k]) {
ok = false;
break;
}
}
}
if (ok) {
if (cc > ans) {
ans = cc;
cnf = i;
}
}
}
cout << ans << endl;
vector<string> v;
for (int i = 0; i < (int)n; i++) {
if ((1 << i) & cnf) v.push_back(m1[i]);
}
sort((v).begin(), (v).end());
for (int i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> s(32);
map<pair<string, string>, bool> val;
vector<string> out;
int n;
void solver(int x, vector<string> d) {
if (x == n) {
if (d.size() > out.size()) out = d;
return;
}
bool check = true;
for (int i = 0; i < d.size(); ++i) {
if (val[make_pair(s[x], d[i])]) check = false;
}
solver(x + 1, d);
if (check == true) {
d.push_back(s[x]);
solver(x + 1, d);
}
}
int main() {
int m, i;
cin >> n >> m;
for (i = 0; i < n; ++i) cin >> s[i];
string a, b;
for (i = 0; i < m; ++i) {
cin >> a >> b;
val[make_pair(a, b)] = true;
val[make_pair(b, a)] = true;
}
vector<string> q;
solver(0, q);
sort(out.begin(), out.end());
cout << out.size() << endl;
for (i = 0; i < out.size(); ++i) cout << out[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int all, bad, ans = 0;
map<string, int> name;
map<int, string> _name;
int dead[16][16];
vector<int> mask;
void dfs(int n, vector<bool>& arr) {
if (n == all) {
for (int i = 0; i < all; i++) {
if (arr[i]) {
for (int j = 0; j < all; j++) {
if (arr[j] && dead[i][j]) {
return;
}
}
}
}
int c = (int)count(arr.begin(), arr.end(), true);
if (c > ans) {
ans = c;
for (int i = 0; i < all; i++) {
mask[i] = arr[i];
}
}
return;
}
dfs(n + 1, arr);
arr[n] = true;
dfs(n + 1, arr);
arr[n] = false;
}
int main() {
cin >> all >> bad;
for (int i = 0; i < all; i++) {
string s;
cin >> s;
name[s] = i;
_name[i] = s;
}
for (int i = 0; i < bad; i++) {
string a, b;
cin >> a >> b;
int x = name[a], y = name[b];
dead[x][y] = 1;
dead[y][x] = 1;
}
mask.resize(all);
vector<bool> arr(all, false);
dfs(0, arr);
cout << ans << endl;
vector<string> k;
for (int i = 0; i < all; i++) {
if (mask[i]) {
k.push_back(_name[i]);
}
}
sort(k.begin(), k.end());
for (auto& i : k) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<string, int> idx;
string name[20];
bool a[20][20];
vector<int> res;
void Try(int k, vector<int> tmp) {
if (tmp.size() > res.size()) res = tmp;
if (k > n) return;
bool ok = true;
for (int i = 0; i < tmp.size(); i++)
if (a[tmp[i]][k]) {
ok = false;
break;
}
if (ok) {
tmp.push_back(k);
Try(k + 1, tmp);
tmp.pop_back();
}
Try(k + 1, tmp);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) cin >> name[i];
sort(name + 1, name + n + 1);
for (int i = 1; i <= n; i++) idx[name[i]] = i;
string s1, s2;
memset(a, false, sizeof(a));
while (m--) {
cin >> s1 >> s2;
int u = idx[s1], v = idx[s2];
a[u][v] = a[v][u] = true;
}
Try(1, vector<int>());
printf("%d\n", res.size());
for (int i = 0; i < res.size(); i++) cout << name[res[i]] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 3;
void read(int &x) {
char ch;
bool flag = 0;
for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1);
ch = getchar())
;
for (x = 0; isdigit(ch); x = (x << 1) + (x << 3) + ch - 48, ch = getchar())
;
x *= 1 - 2 * flag;
}
string fuck[maxn];
int edge[105][105];
map<string, int> cou;
int a[105], b[105];
int out = -1;
vector<string> output;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
fuck[i] = tmp;
cou[tmp] = i;
}
for (int i = 0; i < m; i++) {
string c, d;
cin >> c >> d;
edge[cou[c]][cou[d]] = 1;
edge[cou[d]][cou[c]] = 1;
}
int aa[50];
for (int i = 0; i < (1 << n); i++) {
memset(aa, 0, sizeof(aa));
int top = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
aa[j] = 1;
top++;
}
}
bool f = 1;
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if (aa[j] && aa[k] && edge[j][k]) {
f = 0;
break;
}
}
}
if (!f) continue;
if (top > out) {
out = top;
output.clear();
for (int j = 0; j < n; j++) {
if (aa[j]) output.push_back(fuck[j]);
}
}
}
cout << output.size() << endl;
sort(output.begin(), output.begin() + out);
for (int i = 0; i < output.size(); i++) cout << output[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string arr[20];
vector<string> out;
vector<pair<string, string> > vp(200);
int n, m;
void rec(int idx, vector<string> vec) {
if (idx == n) return;
bool can;
for (int i = idx; i < n; i++) {
can = true;
for (int j = 0; j < int((vec).size()) && can; j++)
for (int k = 0; k < m; k++)
if (arr[i] == vp[k].first && vec[j] == vp[k].second ||
arr[i] == vp[k].second && vec[j] == vp[k].first) {
can = false;
break;
}
if (can) {
vec.push_back(arr[i]);
if (int((vec).size()) > int((out).size())) out = vec;
rec(i + 1, vec);
vec.pop_back();
}
}
}
int main() {
vector<string> v;
string x, y;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < m; i++) cin >> vp[i].first >> vp[i].second;
rec(0, v);
cout << int((out).size()) << endl;
for (int i = 0; i < int((out).size()); i++) cout << out[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[17];
char s[20][20];
int n, m;
int chage(char *str) {
for (int i = 0; i < n; i++)
if (!strcmp(s[i], str)) return i;
}
int mapp[20][20];
int chage2(int x) {
int sum = 0;
while (x) {
x &= x - 1;
sum++;
}
return sum;
}
int main() {
while (cin >> n >> m) {
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (strcmp(s[i], s[j]) > 0) {
strcpy(s[n], s[i]);
strcpy(s[i], s[j]);
strcpy(s[j], s[n]);
}
}
}
while (m--) {
scanf("%s%s", s[n], s[n + 1]);
int x = chage(s[n]);
int y = chage(s[n + 1]);
mapp[x][y] = mapp[y][x] = 1;
}
int maxx = 1 << n;
int tmp = 0;
for (int i = 0; i < maxx; i++) {
int flag = 1;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
for (int k = j + 1; k < n; k++) {
if (i & (1 << k)) {
if (mapp[j][k] == 1) {
flag = 0;
break;
}
}
}
}
}
if (flag == 1) {
if (chage2(i) > chage2(tmp)) tmp = i;
}
}
printf("%d\n", chage2(tmp));
for (int i = 0; i < n; i++) {
if (tmp & (1 << i)) printf("%s\n", s[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
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;
}
long long aa[100];
int main() {
map<string, int> mp;
long long a, b;
string s[17];
int m[17][17];
while (cin >> a >> b) {
memset(m, 0, sizeof(m));
mp.clear();
int cnt = 0;
for (int i = 0; i < a; i++) {
cin >> s[i];
mp[s[i]] = i;
}
string t1, t2;
for (int j = 0; j < b; j++) {
cin >> t1 >> t2;
m[mp[t1]][mp[t2]] = m[mp[t2]][mp[t1]] = 1;
}
vector<string> ans;
int mm = 0, now = 0;
for (int i = 0; i < (1 << (a)); i++) {
bool flag = true;
int tans = 0;
for (int j = 0; j < a; j++)
if ((((i) & (1 << (j))) != 0)) tans++;
if (tans <= mm) continue;
for (int j = 0; j < a && flag; j++)
if ((((i) & (1 << (j))) != 0))
for (int k = 0; k < a && flag; k++) {
if ((((i) & (1 << (k))) != 0))
if (m[j][k]) flag = false;
}
if (flag) {
mm = tans;
now = i;
}
}
for (int i = 0; i < a; i++) {
if ((((now) & (1 << (i))) != 0)) ans.push_back(s[i]);
}
sort(ans.begin(), ans.end());
cout << mm << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 17;
int a[N][N], n, m, best, bestn;
string s, t, S[N];
char buff[20];
map<string, int> M;
vector<string> ans;
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 = 0;
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;
}
for (int i = 0; i < n; i++)
if (best & (1 << i)) ans.push_back(S[i]);
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%s\n", ans[i].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<string, int> names;
string name_from_ind[n];
for (int i = 0; i < n; i++) {
string nm;
cin >> nm;
names[nm] = i;
name_from_ind[i] = nm;
}
vector<pair<int, int> > pairs;
for (int i = 0; i < m; i++) {
string a, b;
cin >> a >> b;
pairs.push_back(pair<int, int>(names[a], names[b]));
}
int N = (1 << n);
vector<string> ans;
for (int i = 0; i < N; i++) {
bool valid = true;
for (int j = 0; j < m; j++) {
int a = pairs[j].first;
int b = pairs[j].second;
if (((i & (1 << a)) != 0) && ((i & (1 << b)) != 0)) {
valid = false;
break;
}
}
if (valid) {
vector<string> team;
int count = 0;
for (int j = 0; j < n; j++)
if ((i & (1 << j)) != 0) team.push_back(name_from_ind[j]);
if (team.size() > ans.size()) ans = team;
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (vector<string>::iterator it = ans.begin(); it != ans.end(); it++)
cout << *it << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, c = 0, i, j, ans = 0;
cin >> n >> m;
string s, s1[n], s2;
map<string, long long> a;
vector<pair<long long, long long>> b;
vector<string> ss;
for (i = 0; i < n; i++) {
cin >> s;
a[s] = i;
s1[i] = s;
}
for (i = 0; i < m; i++) {
cin >> s >> s2;
b.push_back({a[s], a[s2]});
}
for (i = 1; i < (1LL << n); i++) {
c = 0;
for (auto x : b) {
long long g = x.first, h = x.second;
if (((1 << g) & i) && ((1 << h) & (i))) {
c = 1;
break;
}
}
if (c == 0 && __builtin_popcountll(i) >= __builtin_popcountll(ans)) {
ans = i;
}
}
cout << __builtin_popcountll(ans) << endl;
for (i = 0; i < 16; i++) {
if (ans & (1 << i)) {
ss.push_back(s1[i]);
}
}
sort(ss.begin(), ss.end());
for (auto x : ss) cout << x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0, maxi = 0;
cin >> n >> m;
vector<string> g(n);
for (int i = 0; i < n; i += 1) {
cin >> g[i];
}
map<pair<string, string>, int> mp;
for (int i = 0; i < m; i += 1) {
string a, b;
cin >> a >> b;
mp[{a, b}] = 1;
mp[{b, a}] = 1;
}
for (int i = 0; i < (1 << n); i += 1) {
bool t = true;
int v = 0;
for (int j = 0; j < n; j += 1) {
if (!(i & (1 << j))) {
continue;
}
v += 1;
for (int k = j + 1; k < n; k += 1) {
if (!(i & (1 << k))) {
continue;
}
if (mp[{g[j], g[k]}] == 1) {
t = false;
break;
}
}
}
if (t && v > maxi) {
maxi = v;
ans = i;
}
}
cout << maxi << endl;
vector<string> ret;
for (int i = 0; i < n; i += 1) {
if (ans & (1 << i)) {
ret.push_back(g[i]);
}
}
sort(ret.begin(), ret.end());
for (string i : ret) {
cout << i << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> p, t;
vector<string> otv;
vector<pair<string, string> > v;
long n, m;
void f(long pos, long next = 0) {
if (pos == n) {
if (otv.size() < next) {
otv = t;
otv.resize(next);
}
return;
}
bool ff = true;
long i, j;
for (i = 0; i < next; i++) {
for (j = 0; j < m; j++)
if (v[j] == make_pair(t[i], p[pos]) || v[j] == make_pair(p[pos], t[i]))
ff = false;
if (!ff) break;
}
if (ff) {
t[next] = p[pos];
f(pos + 1, next + 1);
}
f(pos + 1, next);
}
int main() {
cin >> n >> m;
p.resize(n);
t.resize(n);
v.resize(m);
long i;
for (i = 0; i < n; i++) cin >> p[i];
for (i = 0; i < m; i++) cin >> v[i].first >> v[i].second;
f(0);
cout << otv.size() << endl;
sort(otv.begin(), otv.end());
for (i = 0; i < otv.size(); i++) cout << otv[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int countBits(unsigned int i) {
int numBits = 0;
unsigned int one = 1;
while (i > 0) {
if (i & one == one) numBits++;
i >>= 1;
}
return numBits;
}
int main(void) {
map<string, unsigned int> nametoint;
map<unsigned int, string> inttoname;
vector<unsigned int> pairs;
unsigned int one = 1;
unsigned int n, m;
string currentName, name1, name2;
cin >> n >> m;
for (unsigned int i = 0; i < n; i++) {
cin >> currentName;
nametoint[currentName] = i;
inttoname[i] = currentName;
}
for (unsigned int i = 0; i < m; i++) {
cin >> name1 >> name2;
pairs.push_back((one << nametoint[name1]) | (one << nametoint[name2]));
}
int maxSetSize = 0;
unsigned int configuration = 0;
bool failed = false;
unsigned int q = one << n;
for (unsigned int i = 0; i < q; i++) {
failed = false;
for (unsigned int j = 0; j < m; j++) {
if ((i & pairs[j]) == pairs[j]) {
failed = true;
break;
}
}
if (!failed) {
if (countBits(i) > maxSetSize) {
maxSetSize = countBits(i);
configuration = i;
}
}
}
cout << maxSetSize << '\n';
vector<string> names;
for (unsigned int i = 0; i < n; i++) {
if ((configuration >> i) & one) names.push_back(inttoname[i]);
}
sort(names.begin(), names.end());
for (int i = 0; i < names.size(); i++) cout << names[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string names[100];
bool k[20][20];
map<string, int> mp;
void wellcome() {
cin >> n >> m;
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
k[i][j] = 1;
}
}
for (int i = 1; i <= n; i++) {
cin >> names[i];
mp[names[i]] = i;
}
for (int i = 1; i <= m; i++) {
string a, b;
cin >> a >> b;
int A = mp[a];
int B = mp[b];
k[A][B] = 0;
k[B][A] = 0;
}
}
int main() {
wellcome();
int ansN = 0;
vector<int> ans;
for (int i = 1; i <= n; i++) {
int mxsz[20];
int mx = 0;
fill(mxsz + 0, mxsz + n + 3, 0);
set<int> pm;
for (int j = 1; j <= n; j++) {
pm.insert(j);
}
int I = i;
bool did = 0;
while (!pm.empty()) {
if (did) {
set<int>::iterator it = pm.end();
it--;
I = (*it);
}
did = 1;
mx++;
pm.erase(I);
for (int j = 1; j <= n; j++) {
if (k[I][j] == 1 && mxsz[j] + 1 == mx) {
mxsz[j] = mx;
} else {
pm.erase(j);
}
}
}
int kk = 0;
for (int j = 1; j <= n; j++) {
if (mxsz[j] == mx) {
kk++;
}
}
if (kk > ansN) {
ansN = kk;
ans.clear();
for (int j = 1; j <= n; j++) {
if (mxsz[j] == mx) {
ans.push_back(j);
}
}
}
}
for (int i = 1; i <= n; i++) {
int mxsz[20];
int mx = 0;
fill(mxsz + 0, mxsz + n + 3, 0);
set<int> pm;
for (int j = 1; j <= n; j++) {
pm.insert(j);
}
int I = i;
bool did = 0;
while (!pm.empty()) {
if (did) {
set<int>::iterator it = pm.begin();
I = (*it);
}
did = 1;
mx++;
pm.erase(I);
for (int j = 1; j <= n; j++) {
if (k[I][j] == 1 && mxsz[j] + 1 == mx) {
mxsz[j] = mx;
} else {
pm.erase(j);
}
}
}
int kk = 0;
for (int j = 1; j <= n; j++) {
if (mxsz[j] == mx) {
kk++;
}
}
if (kk > ansN) {
ansN = kk;
ans.clear();
for (int j = 1; j <= n; j++) {
if (mxsz[j] == mx) {
ans.push_back(j);
}
}
}
}
cout << ansN << endl;
vector<string> anss;
for (int i = 0; i < ans.size(); i++) {
anss.push_back(names[ans[i]]);
}
sort(anss.begin(), anss.end());
for (int i = 0; i < anss.size(); i++) {
cout << anss[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = (1e9) + 7;
inline void fastIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
fastIO();
int n, k, ans = 0;
cin >> n >> k;
map<pair<string, string>, int> has;
vector<string> fin(n);
vector<string> input(n);
for (int i = 0; i < n; i++) {
cin >> input[i];
}
for (int i = 0; i < k; i++) {
string a, b;
cin >> a >> b;
has[make_pair(a, b)] = 1;
has[make_pair(b, a)] = 1;
}
for (int i = 0; i <= pow(2, n); i++) {
bool valid = true;
int cnt = 0;
vector<string> temp;
for (int j = 0; j < n && valid; j++) {
if ((i & (1 << j)) != 0) {
cnt++;
temp.push_back(input[j]);
for (int k = 0; k < n && valid; k++) {
if ((i & (1 << k)) != 0) {
if (has[make_pair(input[k], input[j])]) {
valid = false;
}
}
}
}
}
if (valid && cnt > ans) {
for (int k = 0; k < temp.size(); k++) {
fin[k] = temp[k];
}
ans = cnt;
}
}
cout << ans << endl;
sort(fin.begin(), fin.end());
for (int i = 0; i < fin.size(); i++) {
if (fin[i] != "") {
cout << fin[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 20;
bool mat[Maxn][Maxn];
vector<int> ans;
vector<int> finAns;
vector<string> Ans;
string name[16];
int n, m;
int find(string a) {
for (int i = 0; i < n; i++) {
if (a == name[i]) return i;
}
return 0;
}
bool k = 0;
int cnt = 0;
void rec(int Len, int now) {
if (Len == now) {
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < ans.size(); j++) {
if (ans[i] != ans[j] && mat[ans[i]][ans[j]] == 1) return;
}
}
if (finAns.size() < ans.size()) {
finAns = ans;
}
return;
}
ans.push_back(now);
cnt++;
rec(Len, now + 1);
ans.pop_back();
cnt--;
rec(Len, now + 1);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> name[i];
}
for (int i = 0; i < m; i++) {
string u, v;
cin >> u >> v;
mat[find(u)][find(v)] = 1;
mat[find(v)][find(u)] = 1;
}
rec(n, 0);
cout << finAns.size() << endl;
for (int i = 0; i < finAns.size(); i++) {
Ans.push_back(name[finAns[i]]);
}
sort(Ans.begin(), Ans.end());
for (int i = 0; i < Ans.size(); i++) {
cout << Ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, gg[19][19];
string s[19];
map<string, int> M;
vector<string> V;
int res, rb;
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (n); i++) {
cin >> s[i];
M[s[i]] = i;
}
for (int i = (1); i <= (m); i++) {
string a, b;
cin >> a >> b;
int pa = M[a];
int pb = M[b];
gg[pa][pb] = gg[pb][pa] = true;
}
for (int i = (0); i <= ((1 << n) - 1); i++) {
int cnt = 0;
for (int j = (0); j <= (n - 1); j++)
if (i & (1 << j)) {
cnt++;
for (int k = (0); k <= (n - 1); k++)
if (i & (1 << k))
if (gg[j + 1][k + 1]) cnt = -999;
}
if (cnt > res) {
res = cnt;
rb = i;
}
}
printf("%d\n", res);
for (int i = (0); i <= (n - 1); i++)
if (rb & (1 << i)) V.push_back(s[i + 1]);
sort(V.begin(), V.end());
for (int i = (0); i <= (res - 1); i++) cout << V[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool a[18][18];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) a[i][j] = 1;
}
map<string, int> mp;
string name;
vector<string> names(n);
for (int i = 0; i < n; i++) {
cin >> name;
mp[name] = i;
names[i] = name;
}
string s1, s2;
for (int i = 0; i < m; i++) {
cin >> s1 >> s2;
a[mp[s1]][mp[s2]] = 0;
a[mp[s2]][mp[s1]] = 0;
}
int res = 0;
vector<int> v;
vector<int> vres;
for (int i = 1; i < (1 << n); i++) {
v.clear();
for (int j = 0; j < n; j++) {
if ((1 << j) & i) {
v.push_back(j);
}
}
bool b = true;
for (int j = 0; j < v.size(); j++) {
for (int k = j + 1; k < v.size(); k++) {
if (!a[v[j]][v[k]]) {
b = false;
break;
}
}
}
if (b) {
if (v.size() > res) {
res = v.size();
vres = v;
}
}
}
cout << res << endl;
vector<string> team;
for (int i = 0; i < vres.size(); i++) {
team.push_back(names[vres[i]]);
}
sort(team.begin(), team.end());
for (int i = 0; i < team.size(); i++) {
if (i != 0) cout << endl;
cout << team[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[17][13];
char a[13], b[13];
int g[17][17];
int len[17];
int ans[17];
int n, m;
int rec;
string d[17];
string e[17];
void mergesort(string *a, string *b, int n) {
int i, i0, i1, iRight, iEnd, width, j;
for (width = 1; width < n; width *= 2)
for (i = 0; i < n; i += width * 2) {
i0 = i;
i1 = iRight = min(i + width, n);
iEnd = min(i + width * 2, n);
for (j = i; j < iEnd; j++)
if (i0 < iRight && (i1 == iEnd || a[i0] < a[i1]))
b[j] = a[i0++];
else
b[j] = a[i1++];
for (j = i; j < iEnd; j++) a[j] = b[j];
}
}
int main() {
scanf("%d %d", &n, &m);
int i, j;
int ind1, ind2;
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
for (len[i] = 0; s[i][len[i]]; len[i]++)
;
}
int l1, l2;
for (i = 0; i < m; i++) {
scanf("%s %s", a, b);
for (l1 = 0; a[l1]; l1++)
;
for (l2 = 0; b[l2]; l2++)
;
for (ind1 = 0; ind1 < n; ind1++)
if (len[ind1] == l1) {
for (j = 0; j < l1; j++) {
if (s[ind1][j] != a[j]) break;
}
if (j == l1) break;
}
for (ind2 = 0; ind2 < n; ind2++)
if (len[ind2] == l2) {
for (j = 0; j < l2; j++) {
if (s[ind2][j] != b[j]) break;
}
if (j == l2) break;
}
g[ind1][ind2] = g[ind2][ind1] = -1;
}
int temp;
int res[17];
int coun, coun2;
for (i = 1; i < (1 << n); i++) {
temp = i;
coun = 0;
coun2 = 0;
while (temp > 0) {
if ((temp & 1) > 0) res[coun++] = coun2;
coun2++;
temp >>= 1;
}
for (l1 = 0; l1 < coun; l1++)
for (l2 = l1 + 1; l2 < coun; l2++)
if (g[res[l1]][res[l2]] < 0) {
l1 = 20;
break;
}
if (l1 < 19 && coun > rec) {
rec = coun;
for (j = 0; j < coun; j++) ans[j] = res[j];
}
}
printf("%d\n", rec);
for (i = 0; i < rec; i++) d[i] = s[ans[i]];
mergesort(d, e, rec);
for (i = 0; i < rec; i++) cout << d[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
vector<string> vec;
string inv[20];
int e[20][20];
int n, m, ma = -1, maxn;
string a, b;
int cnt(int a) {
int c;
for (int i = 0; i < n; i++)
if (a & (1 << i)) c++;
return c;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> inv[i];
mp[inv[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> a >> b;
e[mp[a]][mp[b]] = e[mp[b]][mp[a]] = 1;
}
for (int te = 0; te < (1 << n); te++) {
if (cnt(te) <= cnt(maxn)) continue;
bool ok = true;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((te & (1 << i)) && (te & (1 << j)) && e[i][j] == 1) {
ok = false;
break;
}
}
if (ok == false) break;
}
if (ok == false) continue;
maxn = te;
}
for (int i = 0; i < n; i++)
if (maxn & (1 << i)) vec.push_back(inv[i]);
sort(vec.begin(), vec.end());
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++) cout << vec[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, counts[20];
string in[20], lhs, rhs, temp;
map<string, int> hs;
vector<int> ps[20];
int main() {
int i, j;
cin >> n >> m;
for ((i) = 0; (i) < (int)n; (i)++) {
cin >> in[i];
hs.insert(make_pair(in[i], i));
}
for ((i) = 0; (i) < (int)m; (i)++) {
cin >> lhs >> rhs;
ps[hs[lhs]].push_back(hs[rhs]);
ps[hs[rhs]].push_back(hs[lhs]);
}
int res = 0;
int resCount = 0;
for (int S = 0; S < (1 << n); S++) {
bool ok = true;
for ((i) = 0; (i) < (int)n; (i)++)
if ((1 << i) & S) {
int psz = ps[i].size();
for ((j) = 0; (j) < (int)psz; (j)++)
if ((1 << ps[i][j]) & S) {
ok = false;
i = n;
j = psz;
}
}
if (!ok) continue;
int tempCount = 0;
for ((i) = 0; (i) < (int)n; (i)++)
if ((1 << i) & S) tempCount++;
if (resCount < tempCount) {
resCount = tempCount;
res = S;
}
}
vector<string> ans;
for ((i) = 0; (i) < (int)n; (i)++)
if ((1 << i) & res) ans.push_back(in[i]);
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
int asz = ans.size();
for ((i) = 0; (i) < (int)asz; (i)++) {
cout << ans[i] << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.