text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 8;
const int INF = 1e9 + 8;
int n, m, col[N], vis[N], save[N], cost[2][N], CurColor, pos[N], TPLT, cnt;
long long sum[2] = {0, 0};
bool flag;
vector<pair<int, int> > a[N];
vector<int> L[N], E[N], ans[2][N], tmp;
void Enter() {
cin >> n >> m;
for (int i = (1), _b = (m); i <= _b; ++i) {
int x, y;
char w;
cin >> x >> y >> w;
save[i] = (w == 'R' ? 0 : 1);
a[x].push_back(pair<int, int>(y, i));
a[y].push_back(pair<int, int>(x, i));
}
}
void Separate(int u) {
pos[u] = TPLT;
L[TPLT].push_back(u);
for (int i = (0), _b = (a[u].size()); i < _b; ++i)
if (!pos[a[u][i].first]) Separate(a[u][i].first);
}
void Reset(int z) {
for (int v : L[z]) vis[v] = -1;
for (int i : E[z]) col[i] = save[i];
tmp.clear();
flag = true;
}
void SaveAns(int z, int cc) {
if (!flag) return;
if (cost[cc][z] > tmp.size()) {
cost[cc][z] = tmp.size();
ans[cc][z] = tmp;
}
}
void DFS(int u, int pick, int cc) {
vis[u] = pick;
if (pick) {
tmp.push_back(u);
for (pair<int, int> e : a[u]) col[e.second] ^= 1;
}
for (pair<int, int> e : a[u]) {
int v = e.first, id = e.second;
if (vis[v] != -1 && col[id] != cc) flag = false;
if (!flag) return;
if (vis[v] == -1) {
if (col[id] == cc)
DFS(v, 0, cc);
else
DFS(v, 1, cc);
}
}
}
void Print(int cc) {
cout << sum[cc] << '\n';
for (int u = (1), _b = (n); u <= _b; ++u)
for (int v : ans[cc][u]) cout << v << ' ';
}
void Process() {
for (int i = (1), _b = (n); i <= _b; ++i)
if (!pos[i]) {
++TPLT;
Separate(i);
}
for (int u = (1), _b = (n); u <= _b; ++u)
for (int i = (0), _b = (a[u].size()); i < _b; ++i) {
int v = a[u][i].first, id = a[u][i].second;
if (pos[u] == pos[v] && u < v) E[pos[u]].push_back(id);
}
for (int c = (0), _b = (2); c < _b; ++c)
for (int i = (1), _b = (TPLT); i <= _b; ++i) cost[c][i] = INF;
for (int z = (1), _b = (TPLT); z <= _b; ++z)
for (int CurColor = (0), _b = (2); CurColor < _b; ++CurColor) {
Reset(z);
DFS(L[z][0], 0, CurColor);
SaveAns(z, CurColor);
Reset(z);
DFS(L[z][0], 1, CurColor);
SaveAns(z, CurColor);
}
for (int i = (1), _b = (TPLT); i <= _b; ++i)
for (int cc = (0), _b = (2); cc < _b; ++cc) sum[cc] += cost[cc][i];
if (sum[0] >= INF && sum[1] >= INF)
cout << -1;
else if (sum[0] < sum[1])
Print(0);
else
Print(1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Enter();
Process();
return 0;
}
|
#include <bits/stdc++.h>
using std::copy;
using std::inserter;
using std::swap;
using std::vector;
const int MAX_N = 100000 + 10;
struct Edge {
int v, color;
};
int n;
vector<Edge> G[MAX_N];
int num_cc;
int cc_id[MAX_N];
vector<int> cc[MAX_N];
int color[MAX_N];
void ReadGraph(void) {
int m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
char s[2];
scanf("%d%d%s", &u, &v, s);
int color = s[0] == 'R';
G[u - 1].push_back((Edge){v - 1, color});
G[v - 1].push_back((Edge){u - 1, color});
}
}
void DFS(int u) {
cc_id[u] = num_cc;
cc[num_cc].push_back(u);
for (int i = 0; i < (int)G[u].size(); ++i) {
Edge &e = G[u][i];
if (cc_id[e.v] == -1) {
DFS(e.v);
}
}
}
void FindCC(void) {
num_cc = 0;
memset(cc_id, -1, sizeof cc_id);
for (int i = 0; i < n; ++i) {
if (cc_id[i] == -1) {
cc[num_cc].clear();
DFS(i);
++num_cc;
}
}
}
void ChooseBetter(bool &good1, vector<int> &list1, bool &good2,
vector<int> &list2) {
if (good2 && (!good1 || list1.size() > list2.size())) {
swap(good1, good2);
swap(list1, list2);
}
}
void WriteList(vector<int> &list) {
printf("%u\n", list.size());
for (int i = 0; i < (int)list.size(); ++i) {
printf("%d ", list[i] + 1);
}
printf("\n");
}
bool DFS2(int u, int goal, vector<int> &list) {
for (int i = 0; i < (int)G[u].size(); ++i) {
Edge &e = G[u][i];
if (e.color == goal) {
if (color[e.v] == -1) {
color[e.v] = color[u];
if (color[e.v]) {
list.push_back(e.v);
}
if (!DFS2(e.v, goal, list)) {
return false;
}
} else if (color[e.v] != color[u]) {
return false;
}
} else {
if (color[e.v] == -1) {
color[e.v] = color[u] ^ 1;
if (color[e.v]) {
list.push_back(e.v);
}
if (!DFS2(e.v, goal, list)) {
return false;
}
} else if (color[e.v] == color[u]) {
return false;
}
}
}
return true;
}
bool SolveCC(int id, int goal, vector<int> &list) {
int root = cc[id].front();
bool good1, good2;
vector<int> now1, now2;
for (int i = 0; i < (int)cc[id].size(); ++i) {
color[cc[id][i]] = -1;
}
color[root] = 0;
good1 = DFS2(root, goal, now1);
for (int i = 0; i < (int)cc[id].size(); ++i) {
color[cc[id][i]] = -1;
}
color[root] = 1;
now2.push_back(root);
good2 = DFS2(root, goal, now2);
ChooseBetter(good1, now1, good2, now2);
if (good1) {
copy(now1.begin(), now1.end(), inserter(list, list.end()));
return true;
} else {
return false;
}
}
void Solve(int goal, bool &good, vector<int> &list) {
list.clear();
for (int i = 0; i < num_cc; ++i) {
if (!SolveCC(i, goal, list)) {
good = false;
return;
}
}
good = true;
}
int main(void) {
ReadGraph();
FindCC();
bool good1, good2;
vector<int> list1, list2;
Solve(0, good1, list1);
Solve(1, good2, list2);
ChooseBetter(good1, list1, good2, list2);
if (good1) {
WriteList(list1);
} else {
puts("-1");
}
}
|
#include <bits/stdc++.h>
const int N = 5e5 + 100;
int n, m;
std::vector<std::pair<int, int> > edge[2];
std::vector<int> graph[N];
bool visit[N];
void init() {
std::cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
char cc[10];
scanf("%d%d%s", &u, &v, cc);
if (cc[0] == 'B') {
w = 0;
} else {
w = 1;
}
edge[w].push_back(std::make_pair(u, v));
}
}
void dfs(int u, std::vector<int> &vec0, std::vector<int> &vec1) {
if (u <= n) {
vec0.push_back(u);
} else {
vec1.push_back(u - n);
}
visit[u] = true;
for (int i = 0; i < (int)graph[u].size(); i++) {
int v = graph[u][i];
if (visit[v] == true) {
continue;
}
dfs(v, vec0, vec1);
}
}
void solve(int t, std::vector<int> &answer) {
for (int i = 1; i <= 2 * n; i++) {
graph[i].clear();
}
std::fill(visit + 1, visit + 2 * n + 1, false);
std::vector<int> vec;
for (int i = 0; i < (int)edge[t].size(); i++) {
int u = edge[t][i].first, v = edge[t][i].second;
graph[u].push_back(v);
graph[v].push_back(u);
graph[n + u].push_back(n + v);
graph[n + v].push_back(n + u);
}
for (int i = 0; i < (int)edge[t ^ 1].size(); i++) {
int u = edge[t ^ 1][i].first, v = edge[t ^ 1][i].second;
graph[u].push_back(n + v);
graph[n + v].push_back(u);
graph[v].push_back(n + u);
graph[n + u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!visit[i] && !visit[i + n]) {
std::vector<int> t[2];
dfs(i, t[0], t[1]);
if (t[0].size() > t[1].size()) {
std::swap(t[0], t[1]);
}
for (int j = 0; j < (int)t[0].size(); j++) {
vec.push_back(t[0][j]);
}
}
}
for (int i = 1; i <= n; i++) {
if (visit[i] && visit[i + n]) {
return;
}
}
if (vec.size() < answer.size() || (answer.size() > 0 && answer[0] == -1)) {
answer = vec;
}
}
void work() {
std::vector<int> answer(1, -1);
solve(0, answer);
solve(1, answer);
if (answer.size() > 0 && answer[0] == -1) {
std::cout << -1 << std::endl;
} else {
std::cout << answer.size() << std::endl;
for (int i = 0; i < (int)answer.size(); i++) {
printf("%d ", answer[i]);
}
std::cout << std::endl;
}
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[101010];
vector<char> c[101010];
int t[101010];
char z;
int e1[101010], e2[101010];
void haku1(int s) {
if (t[s] == -1) return;
t[s] = -1;
for (int i = 0; i < v[s].size(); i++) {
haku1(v[s][i]);
}
}
bool ok;
int q;
void haku2(int s, int u) {
if (t[s] == u || !ok) return;
if (t[s] != -1) {
ok = false;
return;
}
t[s] = u;
if (u) q++;
for (int i = 0; i < v[s].size(); i++) {
if (c[s][i] == z) {
haku2(v[s][i], u);
} else {
haku2(v[s][i], 1 - u);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
char x;
cin >> a >> b >> x;
v[a].push_back(b);
v[b].push_back(a);
c[a].push_back(x);
c[b].push_back(x);
}
int w1 = 0, w2 = 0;
bool k1 = true, k2 = true;
z = 'R';
for (int i = 1; i <= n; i++) haku1(i);
for (int i = 1; i <= n; i++) {
if (t[i] != -1) continue;
int w = 999999999;
haku1(i);
ok = true;
q = 0;
haku2(i, 0);
if (ok && q < w) {
w = q;
e1[i] = 0;
}
haku1(i);
ok = true;
q = 0;
haku2(i, 1);
if (ok && q < w) {
w = q;
e1[i] = 1;
}
if (w == 999999999) {
k1 = false;
break;
}
w1 += w;
}
z = 'B';
for (int i = 1; i <= n; i++) haku1(i);
for (int i = 1; i <= n; i++) {
if (t[i] != -1) continue;
int w = 999999999;
haku1(i);
ok = true;
q = 0;
haku2(i, 0);
if (ok && q < w) {
w = q;
e2[i] = 0;
}
haku1(i);
ok = true;
q = 0;
haku2(i, 1);
if (ok && q < w) {
w = q;
e2[i] = 1;
}
if (w == 999999999) {
k2 = false;
break;
}
w2 += w;
}
if (!k1 && !k2) {
cout << "-1\n";
return 0;
}
vector<int> f;
for (int i = 1; i <= n; i++) haku1(i);
if (k1 && (!k2 || w1 < w2)) {
z = 'R';
ok = true;
for (int i = 1; i <= n; i++) {
if (t[i] != -1) continue;
haku2(i, e1[i]);
}
} else {
z = 'B';
ok = true;
for (int i = 1; i <= n; i++) {
if (t[i] != -1) continue;
haku2(i, e2[i]);
}
}
for (int i = 1; i <= n; i++) {
if (t[i] == 1) f.push_back(i);
}
cout << f.size() << "\n";
for (int i = 0; i < f.size(); i++) cout << f[i] << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <typename T, typename... X>
void R(T &head, X &...tail) {
_R(head);
R(tail...);
}
const int N = 100005, INF = -100000000;
vector<pair<int, int> > g[N];
vector<int> v[2], ans[2];
int visit[2][N];
int n, m;
bool DFS(int x, int stat, int p, int c, int vis[]) {
if (vis[x] != -1) return vis[x] == stat;
vis[x] = stat;
if (stat == 1) v[p].push_back(x);
for (pair<int, int> e : g[x])
if (!DFS(e.first, e.second ^ stat ^ c, p, c, vis)) return 0;
return 1;
}
int main() {
R(n, m);
for (int i = 0; i < m; i++) {
int x, y;
char c;
R(x, y, c);
g[x].push_back(make_pair(y, c == 'R'));
g[y].push_back(make_pair(x, c == 'R'));
}
int res[2] = {1, 1};
for (int color = 0; color < 2; color++) {
memset(visit, -1, sizeof(visit));
for (int i = 1; i <= n && res[color]; i++)
if (visit[0][i] == -1) {
int rtv[2];
for (int p = 0; p < 2; p++) v[p].clear();
for (int p = 0; p < 2; p++) rtv[p] = DFS(i, p, p, color, visit[p]);
;
if (max(rtv[0], rtv[1]) == 0)
res[color] = 0;
else {
int ind = (rtv[0] ? v[0].size() : INF) > (rtv[1] ? v[1].size() : INF);
ans[color].insert(ans[color].end(), v[ind].begin(), v[ind].end());
}
}
};
if (max(res[0], res[1]) == 0)
puts("-1");
else {
int ind = (res[0] ? ans[0].size() : INF) > (res[1] ? ans[1].size() : INF);
cout << ans[ind].size() << endl;
for (int i : ans[ind]) printf("%d ", i);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
char s[] = "RB";
char c[100100];
int a[100100], b[100100], ans[2], vst[100100];
vector<int> adj[100100];
vector<int> col[3];
vector<int> seq[2];
bool dfs(int u, int c = 1) {
vst[u] = c;
col[c].push_back(u);
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
if (v > 0) {
if (vst[v]) {
if (vst[v] != vst[u]) return false;
continue;
}
if (!dfs(v, c)) return false;
} else {
v = -v;
if (vst[v]) {
if (vst[v] == vst[u]) return false;
continue;
}
if (!dfs(v, 3 - c)) return false;
}
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d %d %c", a + i, b + i, c + i);
}
for (int tp = 0; tp < 2; tp++) {
for (int i = 1; i <= n; i++) adj[i].clear(), vst[i] = 0;
for (int i = 0; i < m; i++) {
if (c[i] == s[tp]) {
adj[a[i]].push_back(b[i]);
adj[b[i]].push_back(a[i]);
} else {
adj[a[i]].push_back(-b[i]);
adj[b[i]].push_back(-a[i]);
}
}
for (int i = 1; i <= n; i++) {
if (!vst[i]) {
col[1].clear();
col[2].clear();
if (!dfs(i)) {
ans[tp] = 0x3f3f3f3f;
break;
}
int id = 1;
if (col[id].size() > col[2].size()) id = 2;
ans[tp] += col[id].size();
while (col[id].size())
seq[tp].push_back(col[id].back()), col[id].pop_back();
}
}
}
int res = min(ans[0], ans[1]);
printf("%d\n", res == 0x3f3f3f3f ? -1 : res);
int id = 0;
if (ans[0] > ans[1]) id = 1;
while (seq[id].size()) printf("%d ", seq[id].back()), seq[id].pop_back();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<pair<int, int> > adj[100111];
vector<int> res;
vector<int> tmp;
int ans = 0x3f3f3f3f;
int vst[100111];
vector<int> vec[2];
int n, m;
int col[100111];
int dfs(int u, int c, int k) {
vec[c].push_back(u);
vst[u] = 1;
col[u] = c;
for (int i = 0; i < ((int)adj[u].size()); i++) {
int v = adj[u][i].first;
if (adj[u][i].second == k) {
if (vst[v]) {
if (col[v] != c) return 0;
continue;
}
if (dfs(v, c, k) == 0) return 0;
} else {
if (vst[v]) {
if (col[v] != 1 - c) return 0;
continue;
}
if (dfs(v, 1 - c, k) == 0) return 0;
}
}
return 1;
}
int solve(int k) {
memset(vst, 0, sizeof vst);
tmp.clear();
for (int i = 1; i <= n; i++)
if (vst[i] == 0) {
vec[0].clear();
vec[1].clear();
if (dfs(i, 0, k) == 0) return 0;
if (((int)vec[0].size()) < ((int)vec[1].size())) swap(vec[0], vec[1]);
for (int j = 0; j < ((int)vec[1].size()); j++) tmp.push_back(vec[1][j]);
}
return 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
gn(u, v);
char c;
scanf(" %c ", &c);
adj[u].push_back(pair<int, int>(v, c == 'R'));
adj[v].push_back(pair<int, int>(u, c == 'R'));
}
if (solve(0)) res = tmp, smin(ans, ((int)tmp.size()));
if (solve(1) and ((int)tmp.size()) < ans) {
res = tmp;
ans = ((int)tmp.size());
}
if (ans == 0x3f3f3f3f) return puts("-1");
sort(res.begin(), res.end());
cout << ((int)res.size()) << endl;
for (int i = 0; i < ((int)res.size()); i++) {
println(res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100001][2];
vector<int> red_ans;
vector<int> blue_ans;
vector<int> now_v[2];
int visited[100001][2];
bool red = true, blue = true;
bool dfs(int x, int rb) {
now_v[visited[x][rb]].push_back(x);
for (int j = 0; j < 2; j++) {
for (int i = 0; i < graph[x][j].size(); i++) {
int want = visited[x][rb] ^ rb ^ j;
if (visited[graph[x][j][i]][rb] == 2) {
visited[graph[x][j][i]][rb] = want;
if (!dfs(graph[x][j][i], rb)) return false;
} else if (visited[graph[x][j][i]][rb] == 1 - want) {
return false;
}
}
}
return true;
}
void print_blue() {
printf("%d\n", blue_ans.size());
for (int i = 0; i < blue_ans.size(); i++) printf("%d ", blue_ans[i]);
}
void print_red() {
printf("%d\n", red_ans.size());
for (int i = 0; i < red_ans.size(); i++) printf("%d ", red_ans[i]);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int from, to;
char clr;
scanf("%d %d %c", &from, &to, &clr);
graph[from][clr == 'B'].push_back(to);
graph[to][clr == 'B'].push_back(from);
}
for (int i = 1; i <= n; i++) {
visited[i][0] = 2;
visited[i][1] = 2;
}
for (int i = 1; i <= n; i++) {
if (visited[i][0] == 2) {
visited[i][0] = 0;
if (!dfs(i, 0)) {
red = false;
now_v[0].clear();
now_v[1].clear();
break;
}
int target = now_v[0].size() > now_v[1].size();
for (int j = 0; j < now_v[target].size(); j++) {
red_ans.push_back(now_v[target][j]);
}
now_v[0].clear();
now_v[1].clear();
}
}
for (int i = 1; i <= n; i++) {
if (visited[i][1] == 2) {
visited[i][1] = 0;
if (!dfs(i, 1)) {
blue = false;
now_v[0].clear();
now_v[1].clear();
break;
}
int target = now_v[0].size() > now_v[1].size();
for (int j = 0; j < now_v[target].size(); j++) {
blue_ans.push_back(now_v[target][j]);
}
now_v[0].clear();
now_v[1].clear();
}
}
if (red && blue) {
if (red_ans.size() > blue_ans.size()) {
print_blue();
} else {
print_red();
}
} else if (red)
print_red();
else if (blue)
print_blue();
else
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int INF = 1e9;
int n;
vector<pair<int, int> > adj[N];
int target, col[N];
vector<int> nodes;
bool dfs(int u, int c, int &sz, int &p) {
if (col[u] != -1) {
if (col[u] != c) return false;
return true;
}
col[u] = c;
sz++;
p += c;
nodes.push_back(u);
bool res = true;
for (auto e : adj[u]) {
int v, x;
tie(v, x) = e;
res &= dfs(v, c ^ (x != target), sz, p);
}
return res;
}
int best(int u) {
int sz = 0, p = 0;
nodes.clear();
if (!dfs(u, 0, sz, p)) return INF;
int a = p, b = sz - p;
if (a > b) {
swap(a, b);
for (int u : nodes) col[u] ^= 1;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int m;
cin >> n >> m;
while (m--) {
int u, v;
char c;
cin >> u >> v >> c;
u--;
v--;
adj[u].emplace_back(v, c == 'B');
adj[v].emplace_back(u, c == 'B');
}
int ans = INF, t = -1;
for (target = 0; target < 2; target++) {
fill_n(col, n, -1);
long long int cand = 0;
for (int u = 0; u < (int)(n); u++)
if (col[u] == -1) cand += best(u);
if (cand < ans) ans = cand, t = target;
}
if (ans == INF)
cout << -1 << '\n';
else {
cout << ans << endl;
target = t;
fill_n(col, n, -1);
for (int u = 0; u < (int)(n); u++)
if (col[u] == -1) best(u);
for (int u = 0; u < (int)(n); u++)
if (col[u]) cout << u + 1 << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000006;
vector<pair<int, char> > V[MAXN];
bool vis[MAXN];
int n, m;
vector<int> ans, tt, teraz;
int ct;
int odw[MAXN];
bool czy[MAXN];
char jak;
bool ok = 1;
void dfs(int u) {
if (czy[u]) teraz.push_back(u + 1);
assert(odw[u] != ct);
odw[u] = ct;
for (auto it = (V[u]).begin(); it != (V[u]).end(); ++it) {
bool tamten = (it->second != jak) ^ czy[u];
if (odw[it->first] == ct) {
if (tamten != czy[it->first]) {
ok = 0;
return;
}
} else {
czy[it->first] = tamten;
dfs(it->first);
if (!ok) return;
}
}
}
void probuj(char c) {
jak = c;
tt.clear();
int startct = ct;
for (int i = 0; i < (n); ++i)
if (odw[i] <= startct) {
bool ktos = 0;
vector<int> best;
for (int j = 0; j < (2); ++j) {
teraz.clear();
++ct;
ok = 1;
czy[i] = j;
dfs(i);
if (ok && (ktos == 0 || best.size() > teraz.size())) {
ktos = 1;
best = teraz;
}
}
if (!ktos) return;
for (auto it = (best).begin(); it != (best).end(); ++it)
tt.push_back(*it);
}
if (tt.size() < ans.size()) ans = tt;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); ++i) {
int a, b;
char c;
scanf("%d %d %c", &a, &b, &c);
--a;
--b;
V[a].push_back({b, c});
V[b].push_back({a, c});
}
ans.resize(n + 2);
probuj('R');
probuj('B');
if (ans.size() == n + 2)
puts("-1");
else {
printf("%lu\n", ans.size());
for (auto it = (ans).begin(); it != (ans).end(); ++it) printf("%d ", *it);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
void Maximize(T &x, U y) {
if (x < y) {
x = y;
}
}
template <typename T, typename U>
void Minimize(T &x, U y) {
if (x > y) {
x = y;
}
}
template <typename T>
int Sign(const T &x) {
return (x < 0 ? -1 : (x == 0 ? 0 : +1));
}
const int N = 100005;
int n;
int m;
vector<pair<int, bool>> G[N];
vector<int> Set[2];
int Color[N];
void bipartiteDfs(int x, bool Col, bool colSrc, bool &goodSol) {
Color[x] = Col;
Set[Col].push_back(x);
for (pair<int, bool> &Edge : G[x]) {
int y;
bool t;
tie(y, t) = Edge;
if (t == colSrc) {
if (Color[y] == -1) {
bipartiteDfs(y, Col ^ 1, colSrc, goodSol);
} else {
if (Color[y] == Color[x]) {
goodSol = false;
}
}
} else {
if (Color[y] == -1) {
bipartiteDfs(y, Col, colSrc, goodSol);
} else {
if (Color[y] != Color[x]) {
goodSol = false;
}
}
}
}
}
pair<bool, vector<int>> Solve(bool colSrc) {
fill(Color, Color + N, -1);
bool isSol = true;
vector<int> Sol;
for (int i = 1; i <= n; i++) {
if (Color[i] == -1) {
for (int j = 0; j < 2; j++) Set[j].clear();
bipartiteDfs(i, 0, colSrc, isSol);
if (Set[0].size() > Set[1].size()) swap(Set[0], Set[1]);
Sol.insert(Sol.end(), Set[0].begin(), Set[0].end());
}
}
return {isSol, Sol};
}
int main() {
cin.tie(nullptr);
ios_base ::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
char c;
int x, y;
cin >> x >> y >> c;
c = (c == 'B' ? 0 : 1);
G[x].emplace_back(y, c);
G[y].emplace_back(x, c);
}
pair<bool, vector<int>> fiSol = Solve(true);
pair<bool, vector<int>> seSol = Solve(false);
if (fiSol.first == false) {
swap(fiSol, seSol);
}
if (fiSol.first == false) {
cout << "-1\n";
} else {
if (seSol.first == false) {
cout << fiSol.second.size() << "\n";
for (int x : fiSol.second) cout << x << " ";
} else {
if (fiSol.second.size() > seSol.second.size()) {
swap(fiSol, seSol);
}
cout << fiSol.second.size() << "\n";
for (int x : fiSol.second) cout << x << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 110000;
vector<pair<int, int> > e[maxn];
int col[maxn];
int z;
bool dfs(int v, int c, vector<int> &l0, vector<int> &l1) {
if (col[v] != -1) return col[v] == c;
col[v] = c;
(c ? l1 : l0).push_back(v);
for (auto w : e[v]) {
int u = w.first, y = w.second;
if (!dfs(u, c ^ y ^ z, l0, l1)) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(m); ++i) {
int x, y;
char c;
cin >> x >> y >> c;
--x;
--y;
e[x].push_back(make_pair(y, c == 'B'));
e[y].push_back(make_pair(x, c == 'B'));
}
int ansSize = 1e9;
vector<int> ans;
for (z = 0; z < 2; ++z) {
for (int i = 0; i < (int)(n); ++i) col[i] = -1;
vector<int> res;
bool ok = true;
for (int i = 0; i < (int)(n); ++i) {
if (col[i] != -1) continue;
vector<int> l0, l1;
if (!dfs(i, 0, l0, l1)) {
ok = false;
break;
}
if (l0.size() > l1.size()) swap(l0, l1);
for (int x : l0) res.push_back(x);
}
if (!ok) continue;
if (uin(ansSize, (int)res.size())) {
ans = res;
}
}
if (ansSize > n) {
cout << -1 << '\n';
} else {
cout << ansSize << '\n';
for (int x : ans) cout << x + 1 << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> adj[N][2];
vector<int> g[N], ver;
int com[N];
int col[N];
int sz[N];
bool mark[N];
int cc[N];
int n, m, cnt1, cnt2;
bool flag = false;
void dfs(int v, int e, int c) {
com[v] = c;
sz[c]++;
for (auto u : adj[v][e])
if (com[u] == -1) dfs(u, e, c);
for (auto u : adj[v][1 - e])
if (com[u] != -1) {
if (com[u] == com[v]) flag = false;
g[com[v]].push_back(com[u]);
g[com[u]].push_back(com[v]);
}
}
void DFS(int v, int c) {
ver.push_back(v);
col[v] = c;
if (c == 0)
cnt1 += sz[v];
else
cnt2 += sz[v];
for (auto u : g[v])
if (col[u] == -1)
DFS(u, 1 - c);
else if (col[u] == col[v])
flag = false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
char c;
cin >> u >> v >> c;
u--, v--;
int x = 0;
if (c == 'B') x = 1;
adj[v][x].push_back(u);
adj[u][x].push_back(v);
}
int ans = -1;
for (int c = 0; c < 2; c++) {
memset(com, -1, sizeof com);
memset(col, -1, sizeof col);
memset(sz, 0, sizeof sz);
for (int i = 0; i < n; i++) g[i].clear();
flag = true;
int cnt = 0;
for (int i = 0; i < n; i++)
if (com[i] == -1) dfs(i, c, cnt++);
for (int i = 0; i < cnt; i++)
if (col[i] == -1) {
ver.clear();
cnt1 = cnt2 = 0;
DFS(i, 0);
if (cnt1 < cnt2)
for (auto v : ver) col[v] = 1 - col[v];
}
if (flag) {
int p = 0;
for (int i = 0; i < n; i++)
if (col[com[i]] == 1) p++;
if (ans == -1 || p < ans) {
ans = p;
for (int i = 0; i < n; i++) cc[i] = col[com[i]];
}
}
}
cout << ans << "\n";
if (ans == -1) return 0;
for (int i = 0; i < n; i++)
if (cc[i]) cout << i + 1 << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100001;
const int maxm = 200001;
int n, m, s1, s2;
int st[maxn], pv[maxm], pl[maxm], tot;
bool pc[maxm], visit[2][maxn], col[2][maxn], visit2[2][maxn];
void side(int u, int v, bool c) {
pv[++tot] = v;
pc[tot] = c;
pl[tot] = st[u];
st[u] = tot;
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
getchar();
char c = getchar();
side(u, v, c == 'R');
side(v, u, c == 'R');
}
}
bool dfs(int c, int x) {
visit[c][x] = true;
s1++;
s2 += col[c][x];
for (int i = st[x]; i; i = pl[i]) {
int v = pv[i];
if (!visit[c][v]) {
col[c][v] = pc[i] ^ col[c][x] ^ c;
if (!dfs(c, v)) return false;
} else if ((pc[i] ^ col[c][x] ^ col[c][v]) != c)
return false;
}
return true;
}
void dfs2(int c, int x) {
col[c][x] = !col[c][x];
visit2[c][x] = true;
for (int i = st[x]; i; i = pl[i])
if (!visit2[c][pv[i]]) dfs2(c, pv[i]);
}
int solve(int c) {
int ret = 0;
for (int i = 1; i <= n; i++)
if (!visit[c][i]) {
s1 = s2 = 0;
col[c][i] = true;
if (!dfs(c, i)) return -1;
if (s2 > s1 - s2) {
s2 = s1 - s2;
dfs2(c, i);
}
ret += s2;
}
return ret;
}
int main() {
init();
int ans, ans1 = solve(1), ans2 = solve(0);
if (ans1 == -1 && ans2 == -1) {
printf("-1\n");
return 0;
} else if (ans1 != -1 && ans2 == -1)
ans = 1;
else if (ans1 == -1 && ans2 != -1)
ans = 0;
else if (ans1 < ans2)
ans = 1;
else
ans = 0;
if (ans)
printf("%d\n", ans1);
else
printf("%d\n", ans2);
for (int i = 1; i <= n; i++)
if (col[ans][i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
struct Edge {
int a, b;
char c;
};
vector<int> g[200009], rg[200009];
bool used[200009];
vector<int> order, comp;
void top_sort(int v) {
used[v] = true;
for (auto to : g[v]) {
if (!used[to]) top_sort(to);
}
order.push_back(v);
}
void dfs(int v, int c) {
comp[v] = c;
for (auto to : rg[v]) {
if (comp[to] == -1) dfs(to, c);
}
}
int sz;
void add_edge(int a, int sa, int b, int sb) {
int s = a + sz * sa;
int t = b + sz * sb;
g[s].push_back(t);
rg[t].push_back(s);
}
void add_or(int a, int sa, int b, int sb) {
add_edge(a, 1 - sa, b, sb);
add_edge(b, 1 - sb, a, sa);
}
void solve1(vector<Edge> E, vector<vector<int> > &res) {
int i, j;
int n = 2 * sz;
for (i = 0; i < n; i++) {
g[i].clear();
rg[i].clear();
}
order.clear();
for (auto e : E) {
if (e.c == 'B') {
add_or(e.a, 0, e.b, 1);
add_or(e.a, 1, e.b, 0);
} else {
add_or(e.a, 0, e.b, 0);
add_or(e.a, 1, e.b, 1);
}
}
memset(used, 0, n * sizeof(used[0]));
for (i = 0; i < n; i++)
if (!used[i]) top_sort(i);
comp = vector<int>(n, -1);
for (i = 0, j = 0; i < n; i++) {
auto v = order[n - i - 1];
if (comp[v] == -1) dfs(v, j++);
}
for (i = 0; i < sz; i++) {
if (comp[i] == comp[i + sz]) return;
}
res.push_back({});
for (i = 0; i < sz; i++)
if (comp[i] > comp[i + sz]) res.back().push_back(i);
res.push_back({});
for (i = 0; i < sz; i++)
if (comp[i] < comp[i + sz]) res.back().push_back(i);
}
vector<int> gg[200009];
void dfs2(int v) {
comp.push_back(v);
used[v] = 1;
for (auto to : gg[v])
if (!used[to]) dfs2(to);
}
bool solve(int n, vector<Edge> E, vector<int> &res) {
::sz = n;
vector<vector<int> > cands;
solve1(E, cands);
if (cands.empty()) return false;
for (int j = 1; j < (int)cands.size(); j++)
if (cands[j].size() < cands[0].size()) swap(cands[0], cands[j]);
res = cands[0];
return true;
}
int main() {
int n, m;
char c[3];
scanf("%d %d", &n, &m);
vector<Edge> E(m);
for (auto &e : E) {
scanf("%d %d %s", &e.a, &e.b, c);
e.a--;
e.b--;
e.c = c[0];
gg[e.a].push_back(e.b);
gg[e.b].push_back(e.a);
}
vector<int> vc(n);
int csz = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
comp.clear();
dfs2(i);
for (auto w : comp) vc[w] = csz;
csz++;
}
}
vector<vector<Edge> > ee(csz);
for (auto e : E) ee[vc[e.a]].push_back(e);
vector<int> gres;
bool has = false;
for (int round = 0; round < 2; round++) {
vector<int> res;
bool ok = true;
for (auto comp : ee) {
if (round)
for (auto &e : comp) e.c ^= 'R' ^ 'B';
map<int, int> NX;
for (auto &e : comp) NX[e.a] = NX[e.b] = 0;
vector<int> RX;
int cnt = 0;
for (auto &p : NX) {
RX.push_back(p.first);
p.second = cnt++;
}
for (auto &e : comp) e.a = NX[e.a], e.b = NX[e.b];
vector<int> r;
if (!solve(cnt, comp, r)) {
ok = false;
break;
}
for (auto &rr : r) res.push_back(RX[rr]);
}
if (!ok) continue;
if (!has || gres.size() > res.size()) gres = res;
has = true;
}
if (!has) {
puts("-1");
return 0;
}
printf("%d\n", gres.size());
for (auto q : gres) printf("%d ", q + 1);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
const int inf = 1e9;
struct Edge {
int to, next, v;
} e[N << 1];
int head[N], cnt;
void ins(int u, int v, int w) {
e[++cnt] = (Edge){v, head[u], w};
head[u] = cnt;
}
void insert(int u, int v, int w) {
ins(u, v, w);
ins(v, u, w);
}
int u[N], v[N], c[N], n, m, res, col[N], vis[N];
vector<int> con, ans, tmp, c0, c1;
void dfs(int u) {
vis[u] = 1;
con.push_back(u);
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (vis[v]) continue;
col[v] = col[u] ^ e[i].v;
dfs(v);
}
}
void solve() {
for (int i = 1; i <= m; i++) c[i] ^= 1;
memset(head, 0, sizeof(head));
memset(vis, 0, sizeof(vis));
cnt = 0;
for (int i = 1; i <= m; i++) insert(u[i], v[i], c[i]);
tmp.clear();
for (int i = 1; i <= n; i++)
if (!vis[i]) {
col[i] = 0;
con.clear();
dfs(i);
c0.clear();
c1.clear();
for (auto v : con)
if (col[v])
c1.push_back(v);
else
c0.push_back(v);
if ((int)c0.size() < (int)c1.size())
for (auto v : c0) tmp.push_back(v);
else
for (auto v : c1) tmp.push_back(v);
}
for (int i = 1; i <= m; i++)
if (col[u[i]] ^ col[v[i]] ^ c[i]) return;
if ((int)tmp.size() < res) res = (int)tmp.size(), ans = tmp;
}
int main() {
scanf("%d%d", &n, &m);
char s[5];
for (int i = 1; i <= m; i++) {
scanf("%d%d%s", &u[i], &v[i], s);
c[i] = s[0] == 'R';
}
res = inf;
solve();
solve();
if (res == inf)
puts("-1");
else {
printf("%d\n", res);
for (auto i : ans) printf("%d ", i);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
for (__typeof((t).begin()) it = (t).begin(); it != (t).end(); it++) {
if (it != t.begin()) os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
for (__typeof((t).begin()) it = (t).begin(); it != (t).end(); it++) {
if (it != t.begin()) os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
bool unite(int x, int y) {
if ((x = root(x)) != (y = root(y))) {
if (d[y] < d[x]) swap(x, y);
d[x] += d[y];
d[y] = x;
}
return x != y;
}
bool find(int x, int y) { return root(x) == root(y); }
int root(int x) { return d[x] < 0 ? x : d[x] = root(d[x]); }
int size(int x = -1) { return x < 0 ? d.size() : -d[root(x)]; }
};
bool dfs(vector<vector<int> > &g, vector<int> &color, int u, int c,
vector<int> &trace) {
color[u] = c;
trace.push_back(u);
for (int v : g[u]) {
if (color[v] == c) return false;
if (!color[v] && !dfs(g, color, v, -c, trace)) return false;
}
return true;
}
int n, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d", &n, &m);
UnionFind ufr(n), ufb(n);
vector<pair<int, int> > er, emplace_back;
char pr = 'B';
for (int i = 0; i < (int)(m); i++) {
int u, v;
char c;
scanf("%d%d %c", &u, &v, &c);
u--;
v--;
if (pr != c) {
swap(er, emplace_back);
swap(ufr, ufb);
}
pr = c;
er.emplace_back(u, v);
ufb.unite(u, v);
}
vector<int> ans(n + 1);
for (int _ = 0; _ < (int)(2); _++) {
vector<vector<int> > g(n);
for (auto e : er) {
int u, v;
tie(u, v) = e;
u = ufr.root(u);
v = ufr.root(v);
g[u].push_back(v);
g[v].push_back(u);
}
int f = 1;
vector<int> color(n);
int sum = 0;
vector<int> v;
vector<vector<int> > inv(n);
for (int i = 0; i < (int)(n); i++) inv[ufr.root(i)].push_back(i);
for (int i = 0; i < (int)(n); i++)
if (ufr.root(i) == i && !color[i]) {
vector<int> t;
if (!dfs(g, color, i, 1, t)) f = 0;
if (!f) break;
vector<vector<int> > tmp(2);
for (int u : t)
for (int v : inv[u]) tmp[color[u] == 1].push_back(v);
if (tmp[0].size() > tmp[1].size()) swap(tmp[0], tmp[1]);
v.insert(v.end(), (tmp[0]).begin(), (tmp[0]).end());
}
if (f)
if (ans.size() > v.size()) swap(ans, v);
swap(er, emplace_back);
swap(ufr, ufb);
}
if (ans.size() == n + 1)
cout << -1 << endl;
else {
cout << ans.size() << endl;
for (int x : ans) cout << x + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
const int MAXN = 101010;
const int INF = 1029384756;
int N, M;
bool ans[MAXN];
vector<pair<int, char> > edge[MAXN];
int abest;
int vis[MAXN];
int good, bad;
vector<int> vlast;
bool dfs(int v, int p, int c, char cc) {
if (vis[v] != -1) return vis[v] == c;
vis[v] = c;
if (c)
bad++;
else
good++;
vlast.push_back(v);
for (auto e : edge[v]) {
int u = e.first;
int dif = (e.second != cc);
if (u == p) continue;
if (!dfs(u, v, c ^ dif, cc)) return false;
}
return true;
}
void calc2(char cc) {
for (int i = 0; i < N; i++) vis[i] = -1;
for (int i = 0; i < N; i++) {
if (vis[i] != -1) continue;
good = bad = 0;
vlast.clear();
bool res = dfs(i, -1, 0, cc);
if (!res) return;
if (bad > good) {
for (auto v : vlast) vis[v] ^= 1;
}
}
int total = 0;
for (int i = 0; i < N; i++) total += vis[i];
if (total < abest) {
abest = total;
for (int i = 0; i < N; i++) ans[i] = vis[i];
}
}
void calc() {
abest = INF;
calc2('R');
calc2('B');
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < M; i++) {
int u, v;
char c;
cin >> u >> v >> c;
u--;
v--;
edge[u].push_back({v, c});
edge[v].push_back({u, c});
}
calc();
if (abest == INF)
cout << -1 << endl;
else {
cout << abest << endl;
for (int i = 0; i < N; i++)
if (ans[i]) cout << i + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v0, v1;
vector<int> solve(vector<vector<int> > v, int n, bool& has) {
has = true;
vector<int> res;
vector<int> used(n + 1, -1);
for (int i = 1; i <= n; i++) {
if (used[i] != -1) continue;
used[i] = 0;
queue<int> q;
vector<int> cmp;
q.push(i);
while (!q.empty()) {
int x = q.front();
cmp.push_back(x);
q.pop();
for (int to : v[x]) {
int t = abs(to);
int wnt = used[x];
if (to < 0) wnt ^= 1;
if (used[t] == -1) {
used[t] = wnt;
q.push(t);
continue;
}
if (used[t] != wnt) {
has = false;
return res;
}
}
}
int c0 = 0, c1 = 0;
for (int x : cmp) {
if (used[x] == 0)
c0++;
else
c1++;
}
int swp = 0;
if (c1 > c0) swp = 1;
for (int x : cmp) {
if (used[x] ^ swp) {
res.push_back(x);
}
}
}
has = true;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
v0.resize(n + 1);
v1.resize(n + 1);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
char c;
cin >> c;
if (c == 'B') {
v0[x].push_back(y);
v0[y].push_back(x);
v1[x].push_back(-y);
v1[y].push_back(-x);
} else {
v0[x].push_back(-y);
v0[y].push_back(-x);
v1[x].push_back(y);
v1[y].push_back(x);
}
}
bool tmp = false;
bool has = false;
vector<int> ans;
vector<int> ans1 = solve(v0, n, tmp);
if (tmp) {
has = true;
ans = ans1;
}
vector<int> ans2 = solve(v1, n, tmp);
if (tmp) {
if (has == false || ans.size() > ans2.size()) {
ans = ans2;
}
has = true;
}
if (!has) {
cout << -1 << endl;
return 0;
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (int x : ans) cout << x << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int logn = 10;
const int inf = (int)2e9 + 5;
const long long mod = (int)1e9 + 7;
const long long base = 2204234849;
const long long l_inf = (long long)4e18;
const long double pi = acos(-1.0);
const long double eps = 1e-12;
int n, m;
vector<pair<int, int> > g[maxn];
vector<int> g2[maxn];
int comp[maxn], it;
bool used[maxn], used2[maxn];
int sz[maxn];
int col[maxn];
bool painted[maxn];
vector<int> ans;
int best = inf;
void dfs1(int v) {
used[v] = true;
comp[v] = it;
for (pair<int, int> u : g[v]) {
if (!used[u.first] && u.second == 0) dfs1(u.first);
}
}
void dfs2(int v, bool &flag) {
sz[comp[v]]++;
used[v] = true;
for (pair<int, int> u : g[v]) {
if (comp[v] == comp[u.first] && u.second == 1) {
flag = false;
return;
}
if (u.second == 1) {
int x = comp[v], y = comp[u.first];
g2[x].push_back(y);
g2[y].push_back(x);
}
}
for (pair<int, int> u : g[v]) {
if (!used[u.first] && u.second == 0) dfs2(u.first, flag);
if (!flag) return;
}
}
bool good(int v, int dep) {
col[v] = dep & 1;
used[v] = true;
for (int u : g2[v]) {
if (!used[u] && !good(u, dep + 1)) return false;
if (used[u] && col[v] == col[u]) return false;
}
return true;
}
void get(int v, int &a, int &b) {
used[v] = true;
col[v] == 0 ? a += sz[v] : b += sz[v];
for (int u : g2[v])
if (!used[u]) get(u, a, b);
}
void paint(int v, int c) {
if (col[v] == c) painted[v] = true;
used2[v] = true;
for (int u : g2[v]) {
if (!used2[u]) paint(u, c);
}
}
void solve() {
for (int i = 0; i < n; i++) {
for (pair<int, int> &u : g[i]) u.second ^= 1;
g2[i].clear();
}
memset(used, false, sizeof used);
memset(comp, 0, sizeof comp);
memset(sz, 0, sizeof sz);
it = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs1(i);
it++;
}
}
memset(used, false, sizeof used);
bool flag = true;
for (int i = 0; i < n; i++)
if (!used[i]) dfs2(i, flag);
if (!flag) return;
memset(used, false, sizeof used);
memset(col, 0, sizeof col);
for (int i = 0; i < it; i++)
if (!used[i] && !good(i, 0)) return;
memset(used, false, sizeof used);
memset(used2, false, sizeof used2);
memset(painted, false, sizeof painted);
int cnt = 0;
for (int i = 0; i < it; i++) {
if (!used[i]) {
int a = 0, b = 0;
get(i, a, b);
cnt += min(a, b);
if (a < b) {
paint(i, col[i]);
} else {
paint(i, col[i] ^ 1);
}
}
}
if (cnt < best) {
best = cnt;
ans.clear();
for (int i = 0; i < n; i++)
if (painted[comp[i]]) ans.push_back(i + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(12);
cout << fixed;
srand(566);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
char c;
cin >> v >> u >> c;
v--, u--;
g[v].push_back(make_pair(u, c == 'B'));
g[u].push_back(make_pair(v, c == 'B'));
}
solve();
solve();
if (best == inf) {
cout << -1;
exit(0);
}
cout << best << '\n';
for (int a : ans) cout << a << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
int N, M, V[MAX];
bool VV[MAX], flag;
vector<pair<int, char> > adj[MAX];
vector<int> node[2];
void dfs(int cur, char c) {
for (auto &it : adj[cur]) {
int next = it.first;
char t = it.second;
if (V[next] == -1) {
V[next] = (t == c) ? V[cur] : V[cur] ^ 1;
node[V[next]].push_back(next);
dfs(next, c);
} else {
int tt = (t == c) ? V[cur] : V[cur] ^ 1;
if (V[next] != tt) {
flag = false;
return;
}
}
}
}
vector<int> check(char c) {
memset(V, -1, sizeof(V));
vector<int> ret;
for (int i = 0; i < N; ++i) {
if (V[i] == -1) {
flag = true;
V[i] = 0;
node[0].clear();
node[1].clear();
node[0].push_back(i);
dfs(i, c);
if (!flag) return vector<int>(N + 1);
for (int i = 0; i < 2; ++i)
if (node[i].size() <= node[i ^ 1].size()) {
ret.insert(ret.end(), node[i].begin(), node[i].end());
break;
}
}
}
return ret;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) {
int a, b;
char c;
scanf("%d%d %c", &a, &b, &c);
--a, --b;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
vector<int> ans(N + 1);
for (auto c : string("RB")) {
vector<int> temp = check(c);
if (temp.size() < ans.size()) ans = move(temp);
}
if (ans.size() > N)
printf("-1\n");
else {
printf("%d\n", ans.size());
for (int it : ans) printf("%d ", it + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int solve(vector<pair<int, bool> >* G, bool linked, vector<int>& grp,
vector<bool>& gpp) {
queue<pair<int, int> > q;
int p = 0;
int best = 0;
int cg = 1;
while (p < n) {
while (grp[p] != 0 && p < n) {
p++;
}
if (p >= n) {
break;
}
q.push(make_pair(p, cg));
grp[p] = cg;
cg++;
int pcount = 1;
int mcount = 0;
while (!q.empty()) {
auto t = q.front();
q.pop();
int nd = get<0>(t);
int gp = get<1>(t);
for (const auto& edge : G[nd]) {
int tg = get<0>(edge);
int et = get<1>(edge);
if (et != linked) {
if (grp[tg] == 0) {
grp[tg] = gp;
q.push(make_pair(tg, gp));
if (gp > 0) {
pcount++;
} else {
mcount++;
}
} else if (grp[tg] != gp) {
return n + 1;
}
} else {
if (grp[tg] == 0) {
grp[tg] = -gp;
q.push(make_pair(tg, -gp));
if (gp > 0) {
mcount++;
} else {
pcount++;
}
} else if (grp[tg] == gp) {
return n + 1;
}
}
}
}
if (pcount > mcount) {
best += mcount;
gpp.push_back(false);
} else {
best += pcount;
gpp.push_back(true);
}
}
return best;
}
int main() {
ios::sync_with_stdio(false);
int a, b;
char c;
cin >> n >> m;
vector<pair<int, bool> > G[100000];
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
G[a - 1].push_back(make_pair(b - 1, c == 'R'));
G[b - 1].push_back(make_pair(a - 1, c == 'R'));
}
vector<int> grpr(n, 0);
vector<bool> gppr{true};
int r = solve(G, true, grpr, gppr);
vector<int> grpl(n, 0);
vector<bool> gppl{true};
int l = solve(G, false, grpl, gppl);
if (r >= n && l >= n) {
cout << -1;
} else {
if (r > l) {
cout << l << endl;
for (int i = 0; i < n; i++) {
int gp = grpl[i];
int abs = gp < 0 ? (-gp) : gp;
if (gppl[abs] != (gp < 0)) {
cout << i + 1 << " ";
}
}
} else {
cout << r << endl;
for (int i = 0; i < n; i++) {
int gp = grpr[i];
int abs = gp < 0 ? (-gp) : gp;
if (gppr[abs] != (gp < 0)) {
cout << i + 1 << " ";
}
}
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<pair<int, int> > G[N];
vector<int> com;
bool vis[N];
int U, V;
void dfs1(int u) {
com.push_back(u);
vis[u] = true;
for (auto &x : G[u]) {
if (x.second) {
U = u;
V = x.first;
}
if (vis[x.first]) continue;
dfs1(x.first);
}
}
int col[N];
int dfs2(int u) {
vis[u] = true;
int ret = 0;
for (auto &x : G[u]) {
if (vis[x.first]) {
if (col[u] ^ col[x.first] ^ x.second) return 0x3f3f3f3f;
} else {
col[x.first] = col[u] ^ x.second;
ret += col[x.first] + dfs2(x.first);
if (ret >= 0x3f3f3f3f) return 0x3f3f3f3f;
}
}
return ret;
}
vector<int> solve(int n) {
vector<int> ret;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
U = V = -1;
com.clear();
dfs1(i);
if (U == -1) continue;
vector<int> a, b;
for (auto x : com) vis[x] = false;
col[U] = 1;
int A = dfs2(U);
for (auto x : com) {
vis[x] = false;
if (col[x]) a.push_back(x);
}
col[V] = 1;
int B = dfs2(V);
for (auto x : com) {
if (col[x]) b.push_back(x);
}
if (A >= 0x3f3f3f3f && B >= 0x3f3f3f3f) {
return vector<int>{-1};
}
if (A > B) swap(a, b);
for (auto x : a) ret.push_back(x);
}
return ret;
}
inline bool bad(vector<int> &a) { return (int)a.size() == 1 && a[0] == -1; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int u, v, i = 0; i < m; ++i) {
char s[2];
scanf("%d%d%s", &u, &v, s);
int c = *s == 'R';
G[u].push_back(make_pair(v, c));
G[v].push_back(make_pair(u, c));
}
vector<int> A = solve(n);
for (int i = 1; i <= n; ++i) {
for (auto &x : G[i]) {
x.second ^= 1;
}
}
vector<int> B = solve(n);
if (bad(A) && bad(B)) {
puts("-1");
return 0;
}
if (bad(A) || (!bad(B) && B.size() < A.size())) {
swap(A, B);
}
printf("%d\n", A.size());
for (auto x : A) printf("%d ", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int mod = INF;
const int N = 1e6 + 7;
const int T = 1 << 20;
vector<vector<pair<int, int> > > G(N);
set<int> visited;
int klik[N];
int dfs(int start, int klik_w_typa, int do_jakiego, bool clear_vis = true) {
if (clear_vis) visited.clear();
int ret = klik_w_typa;
visited.insert(start);
klik[start] = klik_w_typa;
for (auto& [u, kol] : G[start])
if (!visited.count(u))
ret = min(ret + dfs(u, do_jakiego ^ klik[start] ^ kol, do_jakiego, false),
INF);
else if (do_jakiego ^ klik[start] ^ klik[u] ^ kol)
ret = INF;
return ret;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
char c;
cin >> a >> b >> c;
G[a].push_back({b, c == 'R'});
G[b].push_back({a, c == 'R'});
}
vector<int> cost[2];
vector<int> czy_klikac[2];
set<int> global;
for (int i = 1; i <= n; i++) {
if (!global.count(i)) {
for (int sign = 0; sign <= 1; sign++) {
pair<int, int> wyn = {dfs(i, 0, sign), dfs(i, 1, sign)};
cost[sign].push_back(min(wyn.first, wyn.second));
czy_klikac[sign].push_back(wyn.first > wyn.second);
}
for (auto& u : visited) global.insert(u);
}
}
int best_cost = INF;
int best_sign = -1;
for (int sign = 0; sign <= 1; sign++)
if (accumulate(cost[sign].begin(), cost[sign].end(), 0ll) < best_cost) {
best_cost = accumulate(cost[sign].begin(), cost[sign].end(), 0ll);
best_sign = sign;
}
if (best_sign == -1) {
cout << -1 << '\n';
exit(0);
}
global.clear();
int cnt = 0;
for (int i = 1; i <= n; i++)
if (!global.count(i)) {
dfs(i, czy_klikac[best_sign][cnt++], best_sign);
for (auto& u : visited) global.insert(u);
}
cout << best_cost << '\n';
for (int i = 1; i <= n; i++)
if (klik[i]) cout << i << ' ';
cout << '\n';
}
signed main() {
int test = 1;
for (int i = 0; i < test; i++) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<pair<int, int> > adj[N];
int n, m, d[N];
vector<int> temp;
long long dfs(int cur, int e, int t) {
if ((~d[cur]) && (d[cur] ^ e) != t) return n + 1;
if (~d[cur]) return 0;
d[cur] = (e ^ t);
if (d[cur]) temp.push_back(cur);
long long ret = d[cur];
for (int i = 0; i < adj[cur].size(); ++i) {
int to = adj[cur][i].first;
int c = adj[cur][i].second;
c ^= d[cur];
ret += dfs(to, c, t);
}
return ret;
}
void solve(vector<int> &vec, long long &out, int t) {
memset(d, -1, sizeof d);
vector<int> v1, v2;
temp.clear();
for (int i = 0; i < n; ++i) {
if (d[i] == -1) v1.push_back(dfs(i, 0, t));
}
memset(d, -1, sizeof d);
temp.clear();
for (int i = 0; i < n; ++i) {
if (d[i] == -1) v2.push_back(dfs(i, 1, t));
}
memset(d, -1, sizeof d);
temp.clear();
int j = 0;
out = 0;
for (int i = 0; i < n; ++i) {
if (d[i] == -1) {
if (v1[j] < v2[j])
dfs(i, 0, t);
else
dfs(i, 1, t);
out += min(v1[j], v2[j]);
j++;
}
}
vec = temp;
}
int main() {
scanf("%d", &n), scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int u, v;
char c;
scanf("%d", &u), scanf("%d", &v);
u--, v--;
scanf(" %c", &c);
adj[u].push_back(pair<int, int>(v, (c == 'B' ? 0 : 1)));
adj[v].push_back(pair<int, int>(u, (c == 'B' ? 0 : 1)));
}
long long out1, out2;
vector<int> v1, v2;
solve(v1, out1, 0);
solve(v2, out2, 1);
if (out1 > n && out2 > n) return puts("-1");
if (out2 < out1) swap(out1, out2), swap(v1, v2);
cout << out1 << endl;
for (int i = 0; i < v1.size(); ++i) printf("%d ", v1[i] + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int maxn = 1e5 + 5;
vector<pair<int, int> > V[maxn];
int color[maxn];
vector<int> num[3];
bool dfs(int u, int c, int flag) {
color[u] = c;
num[c].push_back(u);
for (auto e : V[u]) {
int v = e.first;
int f = e.second;
if (color[v] != -1) {
if ((f ^ flag) == 0 && color[u] != color[v]) {
return false;
} else if ((f ^ flag) == 1 && color[u] == color[v]) {
return false;
}
} else {
if ((f ^ flag) == 0) {
bool check = dfs(v, c, flag);
if (!check) return false;
} else {
bool check = dfs(v, c ^ 1, flag);
if (!check) return false;
}
}
}
return true;
}
int n, m;
vector<int> work(int flag) {
vector<int> ans;
memset(color, -1, sizeof(color));
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
num[0].clear();
num[1].clear();
bool f = dfs(i, 0, flag);
if (!f) {
for (int i = 1; i <= n + 1; i++) {
ans.push_back(1);
}
return ans;
}
int chose = 0;
if (num[0].size() > num[1].size()) {
chose = 1;
}
for (int j = 0; j < num[chose].size(); j++) {
ans.push_back(num[chose][j]);
}
}
}
return ans;
}
int main() {
scanf("%d %d", &n, &m);
int u, v;
char s;
for (int i = 1; i <= m; i++) {
scanf("%d %d %c", &u, &v, &s);
int flag = (s == 'B');
V[u].push_back({v, flag});
V[v].push_back({u, flag});
}
vector<int> ans = work(0);
vector<int> ans2 = work(1);
if (ans.size() > n && ans2.size() > n) {
puts("-1");
return 0;
}
if (ans.size() > ans2.size()) {
swap(ans, ans2);
}
cout << ans.size() << endl;
for (auto v : ans) {
printf("%d ", v);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 15;
vector<pair<int, char> > G[maxn];
int N, M, co[maxn], ok1, ok2;
char buffer[20];
vector<int> part[2];
bool dfs(int x, char target) {
for (auto ev : G[x]) {
int v = ev.first;
char c = ev.second;
if (c == target) {
if (co[v] == -1) {
co[v] = co[x];
part[co[v]].push_back(v);
if (!dfs(v, target)) return false;
} else if (co[v] != co[x])
return false;
} else {
if (co[v] == -1) {
co[v] = co[x] ^ 1;
part[co[v]].push_back(v);
if (!dfs(v, target)) return false;
} else if (co[v] == co[x])
return false;
}
}
return true;
}
vector<int> solve(char target) {
memset(co, -1, sizeof(co));
vector<int> res;
for (int i = 1; i <= N; ++i)
if (co[i] == -1) {
for (int j = 0; j < 2; ++j) part[j].clear();
co[i] = 0;
part[0].push_back(i);
if (!dfs(i, target)) {
if (target == 'B')
ok1 = false;
else
ok2 = false;
return res;
}
vector<int>& s = part[0];
if (s.size() > part[1].size()) s = part[1];
for (auto it : s) res.push_back(it);
}
if (target == 'B')
ok1 = true;
else
ok2 = true;
return res;
}
int main(int argc, char* argv[]) {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; ++i) {
int u, v;
scanf("%d%d%s", &u, &v, buffer);
G[u].push_back(make_pair(v, buffer[0]));
G[v].push_back(make_pair(u, buffer[0]));
}
bool ok = false;
vector<int> ans;
vector<int> ta = solve('B');
vector<int> tb = solve('R');
if (ok1 == true) ans = ta, ok = true;
if (ok2 == true) {
if (ok == false)
ans = tb, ok = true;
else if (tb.size() < ta.size())
ans = tb;
}
if (ok == false)
printf("-1\n");
else {
printf("%d\n", (int)ans.size());
for (auto it : ans) printf("%d ", it);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename H>
bool chmin(H& v1, const H v2) {
if (v1 > v2) {
v1 = v2;
return true;
}
return false;
}
template <typename H>
bool chmax(H& v1, const H v2) {
if (v1 < v2) {
v1 = v2;
return true;
}
return false;
}
template <typename H>
void read(H& head) {
cin >> head;
}
template <typename H, typename... T>
void read(H& head, T&... tail) {
cin >> head;
read(tail...);
}
template <typename H>
void write(H head) {
cout << head << '\n';
}
template <typename H, typename... T>
void write(H head, T... tail) {
cout << head << " ";
write(tail...);
}
template <typename... T>
void writef(T... tail) {
write(tail...);
cout << flush;
}
template <typename... T>
void die(T... tok) {
write(tok...);
exit(0);
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
if (v.size()) {
for (int i = 0; i < ((int)(v).size() - 1); ++i) out << v[i] << " ";
out << v.back();
}
return out;
}
using namespace std;
struct Edge {
int color;
int target;
};
vector<Edge> g[100005];
bool vis[100005];
int color[100005];
vector<int> component;
bool fail = 0;
void dfs(int x) {
vis[x] = 1;
component.push_back(x);
for (const Edge& e : g[x]) {
if (!vis[e.target]) {
color[e.target] = (e.color ^ color[x]);
dfs(e.target);
}
if (fail) return;
if (color[e.target] != (e.color ^ color[x])) {
fail = 1;
return;
}
}
}
int main() {
cin >> skipws;
int n, m;
read(n, m);
for (int i = 0; i < (m); ++i) {
int a, b;
char c;
read(a, b, c);
c = c == 'B' ? 1 : 0;
g[a].push_back((Edge){c, b});
g[b].push_back((Edge){c, a});
}
vector<int> pans(n + 1);
for (int j = 0; j < 2; j++) {
for (int i = 1; i < (n + 1); ++i) color[i] = 0, vis[i] = 0;
int fans = 0;
for (int i = 1; i < (n + 1); ++i)
if (!vis[i]) {
component.clear();
dfs(i);
if (fail) goto nextround;
int cnt = 0;
for (int j : component) cnt += color[j];
if (cnt > (int)(component).size() - cnt) {
for (int j : component) color[j] ^= 1;
cnt = (int)(component).size() - cnt;
}
fans += cnt;
}
if (fans < (int)(pans).size()) {
pans.clear();
for (int i = 1; i < (n + 1); ++i)
if (color[i]) pans.push_back(i);
}
nextround:
fail = 0;
for (int i = 1; i < (n + 1); ++i)
for (auto& e : g[i]) e.color ^= 1;
}
if ((int)(pans).size() > n) die(-1);
write((int)(pans).size());
for (int i : pans) cout << i << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
vector<pair<int, int> > lst[N];
int ans = 0;
vector<int> tmp;
bool used[N];
int st1[N];
bool gl[N];
int st[N];
int cnt = 0;
bool dfs(int k) {
used[k] = 1;
tmp.push_back(k);
cnt += st[k];
for (int i = 0; i < (int)lst[k].size(); i++) {
int to = lst[k][i].first;
if (!used[to]) {
st[to] = (st[k] + lst[k][i].second) % 2;
bool tt = dfs(to);
if (!tt) return false;
} else {
if ((st[k] + st[to] + lst[k][i].second) % 2) return false;
}
}
return true;
}
int n, m;
void solve() {
for (int i = 1; i <= n; i++) {
used[i] = 0;
st[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
tmp.clear();
cnt = 0;
if (!dfs(i)) {
ans = 1e9;
return;
}
if (tmp.size() - cnt < cnt) {
ans += tmp.size() - cnt;
for (int j = 0; j < (int)tmp.size(); j++) {
st[tmp[j]] = 1 - st[tmp[j]];
}
} else {
ans += cnt;
}
}
}
}
void bad() {
cout << -1 << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
char c;
cin >> u >> v >> c;
if (c == 'B')
lst[u].push_back(make_pair(v, 0));
else
lst[u].push_back(make_pair(v, 1));
if (c == 'B')
lst[v].push_back(make_pair(u, 0));
else
lst[v].push_back(make_pair(u, 1));
}
solve();
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)lst[i].size(); j++) {
lst[i][j].second = 1 - lst[i][j].second;
}
}
int ans1 = ans;
ans = 0;
memcpy(st1, st, (n + 10) * sizeof(int));
solve();
if (ans > ans1) {
swap(ans, ans1);
swap(st, st1);
}
if (ans >= 1e9 - 1) {
bad();
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (st[i]) {
cout << i << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int maxN = 1 << 17;
vector<int> g0[maxN], g1[maxN], K[maxN], *G, *H, temp[3];
int n, comp[maxN], col[maxN], sz[maxN];
bool fail, compInRes[maxN];
vector<int> res(maxN);
void normal(vector<int>& v) {
sort((v).begin(), (v).end());
v.resize(unique((v).begin(), (v).end()) - v.begin());
}
void dfsComp(int v, int c) {
comp[v] = c;
sz[c]++;
for (int u : G[v])
if (comp[u] == 0) dfsComp(u, c);
}
void dfsCol(int v, int c) {
col[v] = c;
temp[1 + c].push_back(v);
for (int u : K[v]) {
if (col[u] == col[v]) {
fail = true;
return;
}
if (col[u] == 0) dfsCol(u, -c);
}
}
void solve() {
for (int i = (1); i < (int)(n + 1); i++) {
comp[i] = col[i] = sz[i] = compInRes[i] = 0;
K[i].resize(0);
}
int c = 0;
for (int i = (1); i < (int)(n + 1); i++)
if (comp[i] == 0) dfsComp(i, ++c);
for (int i = (1); i < (int)(n + 1); i++)
for (int j : H[i]) {
int a = comp[i], b = comp[j];
if (a == b) return;
K[a].push_back(b);
K[b].push_back(a);
}
for (int i = (1); i < (int)(c + 1); i++) normal(K[i]);
fail = false;
for (int i = (1); i < (int)(c + 1); i++)
if (col[i] == 0) {
dfsCol(i, 1);
int s[3] = {0, 0, 0};
for (int j = (0); j < (int)(3); j++)
for (int v : temp[j]) s[j] += sz[v];
int j = s[0] < s[2] ? 0 : 2;
for (int v : temp[j]) compInRes[v] = true;
for (int j = (0); j < (int)(3); j++) temp[j].resize(0);
}
if (fail) return;
vector<int> prop(0);
for (int i = (1); i < (int)(n + 1); i++)
if (compInRes[comp[i]]) prop.push_back(i);
if (prop.size() < res.size()) res = prop;
}
void ans() {
if (res.size() == maxN) {
printf("-1\n");
return;
}
printf("%d\n", (int)res.size());
for (int v : res) printf("%d ", v);
printf("\n");
}
int main() {
int m;
scanf("%d%d", &n, &m);
while (m--) {
int a, b;
char c[3];
scanf("%d%d%s", &a, &b, c);
G = c[0] == 'R' ? g0 : g1;
G[a].push_back(b);
G[b].push_back(a);
}
G = g0, H = g1;
solve();
swap(G, H);
solve();
ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool SR(int &x) { return scanf("%d", &x) == 1; }
bool SR(long long &x) { return scanf("%lld", &x) == 1; }
bool SR(double &x) { return scanf("%lf", &x) == 1; }
bool SR(char *s) { return scanf("%s", s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
void SP(const int x) { printf("%d", x); }
void SP(const long long x) { printf("%lld", x); }
void SP(const double x) { printf("%.16lf", x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
const int maxn = 4e5 + 5;
int n, m;
int f[maxn], c[maxn];
vector<int> id[maxn];
void read() {
RI(n, m);
for (int i = (1); i <= int(m); i++) {
int a, b;
char s[2];
RI(a, b, s);
f[i] = a ^ b;
c[i] = (s[0] == 'B');
id[a].push_back(i);
id[b].push_back(i);
}
}
int to(int u, int i) { return u ^ f[i]; }
int g[maxn];
vector<int> has[maxn];
bitset<maxn> vis;
void dfs1(int u, int p) {
g[u] = p;
vis[u] = 1;
has[p].push_back(u);
for (auto i : id[u])
if (!vis[to(u, i)]) dfs1(to(u, i), p);
}
void build() {
for (int i = (1); i <= int(n); i++)
if (!vis[i]) dfs1(i, i);
}
int par[maxn << 1];
int find(int u) { return u == par[u] ? u : par[u] = find(par[u]); }
void merge(int a, int b) { par[find(a)] = find(b); }
vector<int> doo(int src) {
for (auto u : has[src]) par[u << 1] = u << 1, par[u << 1 | 1] = u << 1 | 1;
for (auto u : has[src])
for (auto i : id[u]) {
merge(u << 1, (to(u, i) << 1) ^ c[i]);
merge(u << 1 | 1, (to(u, i) << 1) ^ c[i] ^ 1);
}
if (find(src << 1) == find(src << 1 | 1)) return vector<int>(1, -1);
int cnt = 0;
for (auto u : has[src]) cnt += (find(u << 1) == find(src << 1));
if (cnt < ((int)(has[src]).size()) - cnt) {
vector<int> ans;
for (auto u : has[src])
if (find(u << 1) == find(src << 1)) ans.push_back(u);
return ans;
} else {
vector<int> ans;
for (auto u : has[src])
if (find(u << 1 | 1) == find(src << 1)) ans.push_back(u);
return ans;
}
}
void sol() {
vector<int> ans1, ans2;
for (int i = (1); i <= int(n); i++)
if (g[i] == i) {
vector<int> sub = doo(i);
ans1.insert(ans1.end(), (sub).begin(), (sub).end());
}
sort((ans1).begin(), (ans1).end());
for (int i = (1); i <= int(m); i++) c[i] ^= 1;
for (int i = (1); i <= int(n); i++)
if (g[i] == i) {
vector<int> sub = doo(i);
ans2.insert(ans2.end(), (sub).begin(), (sub).end());
}
sort((ans2).begin(), (ans2).end());
if (((int)(ans1).size()) && ans1[0] == -1 && ((int)(ans2).size()) &&
ans2[0] == -1) {
PL(-1);
return;
}
if (((int)(ans1).size()) > ((int)(ans2).size())) ans1.swap(ans2);
auto &ans = (((int)(ans1).size()) && ans1[0] == -1 ? ans2 : ans1);
PL(((int)(ans).size()));
for (int i = 0; i < int(((int)(ans).size())); i++)
printf("%d%c", ans[i], " \n"[i == ((int)(ans).size()) - 1]);
}
int main() {
read();
build();
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e17 + 7;
const int N = 1e5 + 7;
const int INF = 2e9 + 7;
const int MOD = 1e9 + 7;
const double Pi = acos(-1.);
const double EPS = 1e-8;
vector<int> e[N], out[2];
int n, m, w, E[N], c[N], vis[N], que[N], ok[2];
char nxtChar() {
char ch = getchar();
while (!(ch == 'R' || ch == 'B')) ch = getchar();
return ch;
}
void chg(int u) {
for (int i = 0; i < ((int)(e[u].size())); ++i) c[e[u][i]] ^= 1;
}
bool check(int tail) {
for (int i = 0; i < tail; ++i) {
int u = que[i];
for (int j = 0; j < ((int)(e[u].size())); ++j)
if (c[e[u][j]] != w) return false;
}
return true;
}
queue<int> Q;
void bfs(int u, int t, vector<int> &r) {
vis[u] = t, Q.push(u);
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int i = 0; i < ((int)(e[u].size())); ++i) {
int v = E[e[u][i]] - u;
if (vis[v] == t) continue;
if (c[e[u][i]] != w) chg(v), r.push_back(v);
vis[v] = t, Q.push(v);
}
}
}
void solve(int u) {
int qh = 0, qt = 0, ans = -1;
vis[u] = 1, que[qt++] = u;
while (qh < qt) {
u = que[qh++];
for (int i = 0; i < ((int)(e[u].size())); ++i) {
int v = E[e[u][i]] - u;
if (vis[v] == 1) continue;
vis[v] = 1;
que[qt++] = v;
}
}
vector<int> ret[2];
u = que[0];
for (int i = 0; i < 2; ++i) {
if (!i) chg(u), ret[i].push_back(u);
bfs(u, 2 + i, ret[i]);
if (check(qt) &&
(ans == -1 || ((int)(ret[ans].size())) > ((int)(ret[i].size()))))
ans = i;
for (int j = 0; j < ((int)(ret[i].size())); ++j) chg(ret[i][j]);
}
if (~ans) {
for (int i = 0; i < ((int)(ret[ans].size())); ++i)
out[w].push_back(ret[ans][i]);
} else {
ok[w] = false;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
E[i] = u + v;
c[i] = (nxtChar() == 'R');
e[u].push_back(i), e[v].push_back(i);
}
int ans = -1;
for (w = 0; w < 2; ++w) {
for (int i = 0; i < n; ++i) vis[i] = 0;
ok[w] = true, out[w].clear();
for (int i = 0; i < n; ++i)
if (vis[i] == 0) solve(i);
if (ok[w] &&
(ans == -1 || ((int)(out[ans].size())) > ((int)(out[w].size()))))
ans = w;
}
if (~ans) {
printf("%d\n", ((int)(out[ans].size())));
for (int i = 0; i < ((int)(out[ans].size())); ++i) {
if (i) putchar(' ');
printf("%d", out[ans][i] + 1);
}
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, next;
char d;
};
node e[200011];
int edge[100011];
int taile;
void add(int xx, int yy, char d) {
e[taile].num = yy;
e[taile].d = d;
e[taile].next = edge[xx];
edge[xx] = taile++;
}
int n, m;
int ans;
vector<int> ans0[2];
vector<int> ansa;
vector<int> fin_ans0;
int col[100011];
int num[2];
bool dfs(int now, char dd) {
int i;
for (i = edge[now]; i != -1; i = e[i].next) {
if (col[e[i].num] == -1) {
col[e[i].num] = (e[i].d == dd) ? col[now] : 1 - col[now];
num[col[e[i].num]]++;
ans0[col[e[i].num]].push_back(e[i].num);
if (dfs(e[i].num, dd) == false) return false;
} else {
if (((col[e[i].num] == col[now]) ^ (e[i].d == dd))) {
return false;
}
}
}
return true;
}
int fin_ans;
int main() {
int i, j, k;
int xx, yy;
char d;
scanf("%d %d", &n, &m);
taile = 1;
memset(edge, -1, sizeof(edge));
for (i = 1; i <= m; i++) {
scanf("%d %d %c", &xx, &yy, &d);
add(xx, yy, d);
add(yy, xx, d);
}
fin_ans = 0x3f3f3f3f;
ansa.clear();
ans = 0;
memset(col, -1, sizeof(col));
for (i = 1; i <= n; i++) {
if (col[i] == -1) {
col[i] = 0;
num[0] = 1;
num[1] = 0;
ans0[0].clear();
ans0[1].clear();
ans0[0].push_back(i);
if (dfs(i, 'R') == false) {
break;
}
if (num[0] <= num[1]) {
ans += num[0];
for (j = 0; j < ans0[0].size(); j++) {
ansa.push_back(ans0[0][j]);
}
} else {
ans += num[1];
for (j = 0; j < ans0[1].size(); j++) {
ansa.push_back(ans0[1][j]);
}
}
}
}
if (i > n) {
fin_ans = ans;
fin_ans0 = ansa;
}
ans = 0;
ansa.clear();
memset(col, -1, sizeof(col));
for (i = 1; i <= n; i++) {
if (col[i] == -1) {
col[i] = 0;
num[0] = 1;
num[1] = 0;
ans0[0].clear();
ans0[1].clear();
ans0[0].push_back(i);
if (dfs(i, 'B') == false) {
break;
}
if (num[0] <= num[1]) {
ans += num[0];
for (j = 0; j < ans0[0].size(); j++) {
ansa.push_back(ans0[0][j]);
}
} else {
ans += num[1];
for (j = 0; j < ans0[1].size(); j++) {
ansa.push_back(ans0[1][j]);
}
}
}
}
if (i > n) {
if (fin_ans > ans) {
fin_ans = ans;
fin_ans0 = ansa;
}
}
if (fin_ans != 0x3f3f3f3f) {
cout << fin_ans << endl;
} else {
cout << -1 << endl;
return 0;
}
if (fin_ans > 0) {
for (i = 0; i < fin_ans0.size() - 1; i++) {
cout << fin_ans0[i] << ' ';
}
cout << fin_ans0[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100005;
vector<pair<long long, char>> adj[maxn];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
char c;
cin >> u >> v >> c;
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
vector<long long> res(2e5, 0);
for (long long c : {'R', 'B'}) {
vector<long long> vec;
bool vis[maxn], color[maxn];
for (long long i = 0; i <= n; i++) vis[i] = color[i] = false;
for (long long i = 1; i <= n; i++) {
if (vis[i]) continue;
vector<long long> s, t;
queue<long long> q;
q.push(i);
vis[i] = true;
while (!q.empty()) {
long long u = q.front();
q.pop();
if (color[u])
s.push_back(u);
else
t.push_back(u);
for (pair<long long, char> e : adj[u]) {
if (vis[e.first]) continue;
if (e.second == c)
color[e.first] = !color[u];
else
color[e.first] = color[u];
vis[e.first] = true;
q.push(e.first);
}
}
if (s.size() < t.size())
for (long long u : s) vec.push_back(u);
else
for (long long u : t) vec.push_back(u);
}
bool ok = true;
for (long long u = 1; u <= n; u++) {
for (pair<long long, char> e : adj[u]) {
if (e.second == c)
ok &= color[e.first] != color[u];
else
ok &= color[e.first] == color[u];
}
}
if (!ok) continue;
if (vec.size() < res.size()) res = vec;
}
if (res.size() == 2e5)
cout << "-1\n";
else {
cout << res.size() << '\n';
for (long long i : res) cout << i << ' ';
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
int tp[N][2];
vector<pair<pair<int, int>, char>> ds;
vector<pair<int, int>> adj[N][2];
vector<pair<int, int>> pa[2];
int pa_chosen;
bool chosen[N], chosen_save[N];
int dfs(int u, int u2) {
pa[pa_chosen].push_back({u, u2});
if (tp[u][1 - u2] != 0 && tp[u][1 - u2] == tp[u][u2]) return -1;
int dem = 0;
if (u2 == 1) dem++;
for (auto ed : adj[u][u2]) {
int v = ed.first;
int cc = ed.second;
if (tp[v][cc] == 0) {
tp[v][cc] = tp[u][u2];
int tmp = dfs(v, cc);
if (tmp == -1) return -1;
dem += tmp;
}
}
return dem;
}
void make_edge(int u, int u2, int v, int v2) {
adj[u][u2].push_back({v, v2});
adj[v][v2].push_back({u, u2});
}
int solve(char code) {
for (int i = 1; i <= n; i++) {
adj[i][0].clear();
adj[i][1].clear();
tp[i][0] = tp[i][1] = 0;
chosen[i] = false;
}
for (auto &ed : ds) {
int u = ed.first.first;
int v = ed.first.second;
char cc = ed.second;
if (cc == code) {
make_edge(u, 0, v, 0);
make_edge(u, 1, v, 1);
} else {
make_edge(u, 1, v, 0);
make_edge(u, 0, v, 1);
}
}
int ans = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (tp[i][0] != 0) continue;
cnt++;
tp[i][0] = cnt;
pa[0].clear();
pa[1].clear();
pa_chosen = 0;
int res = dfs(i, 0);
if (res == -1) return -1;
pa_chosen = 1;
cnt++;
tp[i][1] = cnt;
int res2 = dfs(i, 1);
if (res < res2) {
ans += res;
for (auto v : pa[0]) {
if (v.second == 1) chosen[v.first] = true;
}
} else {
ans += res2;
for (auto v : pa[1]) {
if (v.second == 1) chosen[v.first] = true;
}
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
char c;
scanf("%d %d %c", &u, &v, &c);
ds.push_back({{u, v}, c});
}
int ans = solve('B');
for (int i = 1; i <= n; i++) chosen_save[i] = chosen[i];
int ans2 = solve('R');
if (ans2 >= 0 && (ans < 0 || ans2 < ans))
ans = ans2;
else {
for (int i = 1; i <= n; i++) chosen[i] = chosen_save[i];
}
printf("%d\n", ans);
if (ans >= 0) {
for (int i = 1; i <= n; i++)
if (chosen[i]) printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int SIZ_TREE = 3e5 + 10;
int n, m;
struct Node {
int u, v;
Node(int U = 0, int V = 0) {
u = U, v = V;
if (u < v) swap(u, v);
}
bool operator<(const Node A) const {
if (u < A.u || (u == A.u && v < A.v)) return true;
return false;
}
};
vector<int> f[N], ans[2];
vector<Node> edg;
map<Node, bool> col;
bool v[N], opr[N], flag1, flag2, add[N];
int cnt_p, cnt_opr;
void init() {
char s;
int x, y;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
while ((s = getchar()) == ' ')
;
f[y].push_back(x);
f[x].push_back(y);
edg.push_back(Node(x, y));
col[Node(x, y)] = (s == 'R' ? false : true);
}
}
bool dfs(int x) {
v[x] = true;
cnt_p++;
cnt_opr += opr[x];
for (int i = 0; i < f[x].size(); i++) {
int y = f[x][i];
if (v[y]) {
if ((col[Node(x, y)] ^ opr[x] ^ opr[y]) == true) return false;
} else {
opr[y] = col[Node(x, y)] ^ opr[x];
if (!dfs(y)) return false;
}
}
return true;
}
void add_ans(int x, bool s1, int s2) {
if (add[x]) return;
opr[x] ^= s1;
add[x] = true;
if (opr[x]) ans[s2].push_back(x);
for (int i = 0; i < f[x].size(); i++) add_ans(f[x][i], s1, s2);
}
bool solve(int sign) {
memset(opr, 0, sizeof(opr));
memset(v, 0, sizeof(v));
memset(add, 0, sizeof(add));
for (int i = 1; i <= n; i++)
if (!v[i]) {
cnt_opr = cnt_p = 0;
if (!dfs(i)) return false;
add_ans(i, (cnt_opr * 2 > cnt_p), sign);
}
return true;
}
void print(int s) {
printf("%d\n", ans[s].size());
for (int i = 0; i < ans[s].size(); i++) printf("%d ", ans[s][i]);
printf("\n");
}
void work() {
flag1 = solve(0);
for (int i = 0; i < edg.size(); i++) col[edg[i]] = (!col[edg[i]]);
flag2 = solve(1);
if (!flag1 && !flag2)
printf("-1\n");
else if (flag1 && !flag2)
print(0);
else if (!flag1 && flag2)
print(1);
else if (ans[0].size() < ans[1].size())
print(0);
else
print(1);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 1000 + 100;
pair<int, int> edge[maxN];
char t[maxN];
int par[maxN];
int dfind(int u) { return par[u] < 0 ? u : par[u] = dfind(par[u]); }
void merge(int u, int v) {
u = dfind(u);
v = dfind(v);
if (u == v) return;
if ((-par[u] < -par[v])) swap(u, v);
par[u] += par[v];
par[v] = u;
}
int n, m;
vector<int> c[maxN];
int mark[maxN];
int cnt1, cnt2;
void dfs(int s, int co = 0) {
mark[s] = 1 + co;
if (co)
cnt2 += -par[s];
else
cnt1 += -par[s];
for (auto x : c[s])
if (!mark[x]) dfs(x, 1 - co);
}
int gg[maxN];
void dpr(int s, int good, int co = 0) {
mark[s] = 3 + co;
if (good == co) gg[s] = true;
for (auto x : c[s])
if (mark[x] < 3) dpr(x, good, 1 - co);
}
int solve(char ch, bool pr = 0) {
memset(par, -1, sizeof par);
for (int i = 0; i < m; i++)
if (t[i] == ch) merge(edge[i].first, edge[i].second);
for (int i = 0; i < n; i++) c[i].clear();
for (int i = 0; i < m; i++)
if (t[i] != ch) {
int u = dfind(edge[i].first), v = dfind(edge[i].second);
if (u == v) return maxN;
c[u].push_back(v);
c[v].push_back(u);
}
memset(mark, 0, sizeof mark);
int ans = 0;
for (int i = 0; i < n; i++)
if (!mark[i] && par[i] < 0) {
cnt1 = cnt2 = 0;
dfs(i);
ans += min(cnt1, cnt2);
if (pr) {
if (cnt1 < cnt2)
dpr(i, 0);
else
dpr(i, 1);
}
}
for (int i = 0; i < n; i++)
for (auto x : c[i])
if (mark[i] == mark[x]) return maxN;
if (pr) {
cout << ans << endl;
for (int i = 0; i < n; i++)
if (gg[dfind(i)]) cout << i + 1 << ' ';
cout << endl;
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> edge[i].first >> edge[i].second >> t[i];
edge[i].first--;
edge[i].second--;
}
char B = 'B', R = 'R';
int a = solve(B);
int b = solve(R);
if (a == b && b == maxN)
cout << -1 << endl;
else if (a < b)
solve(B, 1);
else
solve(R, 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e5) + 100;
const int oo = int(1e8);
struct LINK {
int id, next, type;
};
int n, m;
int now;
int ans1, ans2;
int choose;
int tail;
int q[maxn];
int h[maxn];
bool done[maxn], vis[maxn];
bool rev[maxn];
LINK t[maxn * 2];
int getnum() {
char ch;
while ((ch = getchar()) != 'R' && ch != 'B')
;
return (ch == 'R');
}
void join(int u, int v, int ty) {
t[now].id = v;
t[now].next = h[u];
t[now].type = ty;
h[u] = now++;
t[now].id = u;
t[now].next = h[v];
t[now].type = ty;
h[v] = now++;
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) h[i] = -1;
for (int i = 1; i <= m; ++i) {
int u, v, type;
scanf("%d%d", &u, &v);
type = getnum();
join(u, v, type);
}
}
void bfs(int st) {
int head = 1;
tail = 1;
q[1] = st;
done[st] = true;
while (head <= tail) {
int cur = q[head++];
for (int i = h[cur]; i > -1; i = t[i].next)
if (!done[t[i].id]) {
q[++tail] = t[i].id;
done[t[i].id] = true;
}
}
}
int calc(int c) {
rev[q[1]] = c;
for (int i = 1; i <= tail; ++i) vis[q[i]] = false;
vis[q[1]] = true;
for (int i = 1; i <= tail; ++i) {
int cur = q[i];
for (int j = h[cur]; j > -1; j = t[j].next) {
if (vis[t[j].id] && ((t[j].type ^ rev[cur] ^ rev[t[j].id]) != choose))
return oo;
if (vis[t[j].id]) continue;
rev[t[j].id] = t[j].type ^ rev[cur] ^ choose;
vis[t[j].id] = true;
}
}
int s = 0;
for (int i = 1; i <= tail; ++i) s += rev[q[i]];
return s;
}
int doit() {
int ans = 0;
for (int i = 1; i <= n; ++i) done[i] = false;
for (int i = 1; i <= n; ++i)
if (!done[i]) {
bfs(i);
int tmp = min(calc(0), calc(1));
if (tmp == oo) return oo;
ans += tmp;
}
return ans;
}
void print() {
for (int i = 1; i <= n; ++i) done[i] = false;
for (int i = 1; i <= n; ++i)
if (!done[i]) {
bfs(i);
int tmp = calc(0);
if (calc(1) > tmp) calc(0);
}
for (int i = 1; i <= n; ++i)
if (rev[i]) printf("%d ", i);
printf("\n");
}
void solve() {
choose = 1;
ans1 = doit();
choose = 0;
ans2 = doit();
if (ans1 <= ans2) choose = 1;
if (min(ans1, ans2) == oo) {
printf("-1\n");
return;
}
if (choose == 1)
printf("%d\n", ans1);
else
printf("%d\n", ans2);
print();
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
#pragma warning(disable : 4996)
using namespace std;
const int N = 1e5 + 100, INF = 1e9;
vector<pair<int, int>> v[N];
int col[N], ch[2][N], used[N];
int g = 0, f = 2;
long long int dfs(int node, int t) {
long long int r = 0;
used[node] = f;
col[node] = t;
r += t;
for (auto p : v[node]) {
int to = p.first, nd = p.second ^ t ^ g;
if (used[to] == f) {
if (nd != col[to]) return INF;
} else
r += dfs(to, nd);
}
return r;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
char a;
scanf("%d%d %c", &x, &y, &a);
x--, y--;
v[x].push_back({y, a == 'R'});
v[y].push_back({x, a == 'R'});
}
int q = 0;
long long int ans = INF, cur;
for (; g < 2; g++) {
memset(used, 0, sizeof(used));
;
memset(col, 0, sizeof(col));
;
cur = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
long long int cc = dfs(i, 0);
f++;
long long int r = dfs(i, 1);
if (r < cc) {
cc = r;
ch[g][i] = 1;
}
cur += cc;
}
}
if (cur < ans) {
ans = cur;
q = g;
}
}
if (ans < INF) {
printf("%lld\n", ans);
memset(col, 0, sizeof(col));
;
memset(used, 0, sizeof(used));
;
g = q;
for (int i = 0; i < n; i++) {
if (!used[i]) dfs(i, ch[q][i]);
}
for (int i = 0; i < n; i++) {
if (col[i]) printf("%d ", i + 1);
}
} else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans = INT_MAX, va[100005], vb[100005], par[100005];
vector<int> vv[100005], tv[2], aa, bb, hv[100005];
bool vc[100005], v[100005], dd[100005];
char x[5];
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
bool ok(int a, bool b) {
if (v[a]) return dd[a] == b;
v[a] = 1;
dd[a] = b;
for (int c = 0; c < hv[a].size(); c++) tv[b].push_back(hv[a][c]);
for (int c = 0; c < vv[a].size(); c++)
if (!ok(vv[a][c], !b)) return 0;
return 1;
}
void go(bool a) {
bb.clear();
for (int b = 1; b <= n; b++)
par[b] = b, vv[b].clear(), v[b] = 0, hv[b].clear();
for (int b = 0; b < m; b++)
if (vc[b] == a) par[find(va[b])] = find(vb[b]);
for (int b = 0; b < m; b++)
if (vc[b] != a) {
if (find(va[b]) == find(vb[b])) return;
vv[par[va[b]]].push_back(par[vb[b]]);
vv[par[vb[b]]].push_back(par[va[b]]);
}
for (int b = 1; b <= n; b++) hv[find(b)].push_back(b);
for (int b = 1; b <= n; b++)
if (par[b] == b && !v[b]) {
tv[0].clear(), tv[1].clear();
if (!ok(b, 0)) return;
if (tv[0].size() < tv[1].size())
for (int c = 0; c < tv[0].size(); c++) bb.push_back(tv[0][c]);
else
for (int c = 0; c < tv[1].size(); c++) bb.push_back(tv[1][c]);
}
if (bb.size() < ans) aa = bb, ans = bb.size();
}
int main() {
scanf("%d%d", &n, &m);
for (int a = 0; a < m; a++) {
scanf("%d%d%s", va + a, vb + a, x);
vc[a] = (x[0] == 'R');
}
go(0), go(1);
if (ans == INT_MAX)
printf("-1\n");
else {
printf("%d\n", ans);
for (int a = 0; a < ans; a++) printf("%d ", aa[a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = (int)1e5 + 10;
vector<pair<int, int> > g[maxN];
int n, m;
int used[maxN];
int getColor(char z) {
if (z == 'B')
return 0;
else
return 1;
}
vector<int> ans_for_comp[2];
int curcolor[maxN];
bool dfs(int v, int color, int f, int p = -1) {
bool ok = true;
used[v] = f;
for (auto t : g[v]) {
int to = t.first;
int clr = t.second;
if (to == p) {
if (((clr ^ color) ^ curcolor[to]) == 1) {
curcolor[v] = 1;
ans_for_comp[f].push_back(v);
} else
curcolor[v] = 0;
}
}
for (auto t : g[v]) {
int to = t.first;
if (used[to] != f) ok &= dfs(to, color, f, v);
int clr = t.second;
if ((clr ^ color) != (curcolor[to] ^ curcolor[v])) ok = false;
}
return ok;
}
vector<int> ans;
vector<int> curans;
bool ok[2];
bool go(int v, int color) {
for (int i = 0; i < 2; i++) {
ans_for_comp[i].clear();
curcolor[v] = i;
ok[i] = dfs(v, color, i);
if (i == 1) ans_for_comp[i].push_back(v);
}
int mn = n + 10;
for (int i = 0; i < 2; i++) {
if (ok[i]) mn = min(mn, (int)ans_for_comp[i].size());
}
for (int i = 0; i < 2; i++) {
if (ok[i] && (mn == ans_for_comp[i].size())) {
for (int j : ans_for_comp[i]) curans.push_back(j);
break;
}
}
return (mn < (n + 10));
}
bool solve(int color) {
memset(used, -1, sizeof used);
curans.clear();
bool ok = true;
for (int i = 1; i <= n; i++) {
if (used[i] == -1) {
ok &= go(i, color);
}
}
return ok;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
char z;
cin >> x >> y >> z;
g[x].push_back(make_pair(y, getColor(z)));
g[y].push_back(make_pair(x, getColor(z)));
}
ans.resize(n + 10);
for (int color = 0; color < 2; color++) {
if (solve(color)) {
if (curans.size() < ans.size()) ans = curans;
}
}
if (ans.size() > n) {
cout << -1;
} else {
cout << ans.size() << '\n';
for (int i : ans) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long k1, k2, n, m, use[200000], use1[200000];
vector<pair<int, int> > edge[200000];
vector<int> dp[2][2], aa, bb;
int dfs(int i, int j) {
int sum = 0;
if (use[i]) aa.push_back(i);
for (auto v : edge[i]) {
int k = (use[i] + v.second) % 2, p = 0;
if (k != j) p = 1;
if (use[v.first] != -1) {
if (use[v.first] != p) {
return n + 1;
}
} else {
use[v.first] = p;
sum += p + dfs(v.first, j);
}
}
return sum;
}
int dfs1(int i, int j) {
int sum = 0;
if (use1[i]) bb.push_back(i);
for (auto v : edge[i]) {
int k = (use1[i] + v.second) % 2, p = 0;
if (k != j) p = 1;
if (use1[v.first] != -1) {
if (use1[v.first] != p) return n + 1;
} else {
use1[v.first] = p;
sum += p + dfs1(v.first, j);
}
}
return sum;
}
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < int(m); i++) {
int a, b;
char c;
cin >> a >> b >> c;
a--;
b--;
int k = 0;
if (c == 'R') k = 1;
edge[a].push_back({b, k});
edge[b].push_back({a, k});
}
long long ans = n + 1;
int nu;
for (int j = 0; j <= 1; j++) {
for (int i = 0; i < int(n); i++) {
use[i] = -1;
use1[i] = -1;
}
long long k = 0;
for (int i = 0; i < int(n); i++) {
if (use[i] == -1) {
use[i] = 0;
aa.resize(0);
bb.resize(0);
if (dfs(i, j) > n) aa.resize(n + 1);
use1[i] = 1;
if (dfs1(i, j) > n) bb.resize(n + 1);
k += min((int)aa.size(), (int)bb.size());
}
}
ans = min(ans, k);
if (ans == k) {
nu = j;
}
}
if (ans == n + 1) {
cout << -1;
return 0;
}
cout << ans << "\n";
for (int i = 0; i < int(n); i++) {
use[i] = -1;
use1[i] = -1;
}
int j = nu;
vector<long long> ans1;
for (int i = 0; i < int(n); i++) {
if (use[i] == -1) {
use[i] = 0;
aa.resize(0);
bb.resize(0);
if (dfs(i, j) > n) aa.resize(n + 1);
use1[i] = 1;
if (dfs1(i, j) > n) bb.resize(n + 1);
if ((int)aa.size() < (int)bb.size()) {
for (int i = 0; i < int((int)aa.size()); i++) ans1.push_back(aa[i] + 1);
} else
for (int i = 0; i < int((int)bb.size()); i++) ans1.push_back(bb[i] + 1);
}
}
sort(ans1.begin(), ans1.end());
for (int i = 0; i < int((int)ans1.size()); i++) cout << ans1[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool all_good;
vector<int> w[2];
vector<int> v1[200000];
vector<int> v2[200000];
int color[200000];
vector<int> res;
int n, m;
int x[200000];
int y[200000];
char q[200000];
void dfs(int x, int c) {
w[c].push_back(x);
if (!all_good) return;
color[x] = c;
for (int i = 0; i < v1[x].size(); i++) {
int to = v1[x][i];
if (color[to] == -1) {
dfs(to, 1 - c);
} else {
if (color[to] == color[x]) {
all_good = false;
return;
}
}
}
for (int i = 0; i < v2[x].size(); i++) {
int to = v2[x][i];
if (color[to] == -1) {
dfs(to, c);
} else {
if (color[to] != color[x]) {
all_good = false;
return;
}
}
}
}
vector<int> solve(char qq) {
res.clear();
all_good = true;
for (int i = 1; i <= n; i++) {
v1[i].clear();
v2[i].clear();
color[i] = -1;
}
for (int i = 1; i <= m; i++)
if (q[i] == qq) {
v1[x[i]].push_back(y[i]);
v1[y[i]].push_back(x[i]);
} else {
v2[x[i]].push_back(y[i]);
v2[y[i]].push_back(x[i]);
}
for (int i = 1; i <= n; i++)
if (color[i] == -1) {
w[0].clear();
w[1].clear();
dfs(i, 0);
if (w[0].size() > w[1].size()) swap(w[0], w[1]);
for (int j = 0; j < w[0].size(); j++) res.push_back(w[0][j]);
}
if (!all_good) {
res.clear();
res.push_back(-1);
}
return res;
}
void prnt(vector<int> a) {
cout << a.size() << "\n";
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
bool fr = true;
bool fb = true;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i] >> q[i];
if (q[i] == 'B')
fb = false;
else
fr = false;
}
if (fb || fr) {
cout << "0\n";
return 0;
}
vector<int> ans1 = solve('B');
vector<int> ans2 = solve('R');
if (ans1[0] == -1 && ans2[0] == -1) {
cout << "-1\n";
return 0;
}
if (ans2[0] == -1 || (ans1[0] != -1 && ans1.size() < ans2.size()))
prnt(ans1);
else
prnt(ans2);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
bool optimal(int N, vvii &E, int &opt, vb &flip) {
bool consistent = true;
vi status(N, -1LL);
vi comp(N, -1LL);
int C = 0;
for (int u = 0; u < N; ++u) {
if (status[u] >= 0) continue;
comp[u] = C;
status[u] = 0LL;
queue<int> q;
q.push(u);
while (!q.empty()) {
int v = q.front();
q.pop();
for (ii wt : E[v]) {
int w = wt.first, t = wt.second;
if (status[w] == -1LL) {
status[w] = (status[v] + t) % 2;
comp[w] = C;
q.push(w);
} else {
if (t == 0 && status[w] != status[v]) consistent = false;
if (t == 1 && status[w] == status[v]) consistent = false;
}
}
}
++C;
}
vvi side(2, vi(C, 0LL));
for (int u = 0; u < N; ++u) {
side[status[u]][comp[u]]++;
}
opt = 0;
flip.assign(N, false);
vb comp_flip(C, false);
for (int c = 0; c < C; ++c) {
if (side[0][c] > side[1][c]) comp_flip[c] = true;
opt += min(side[0][c], side[1][c]);
}
for (int u = 0; u < N; ++u) {
if (status[u] == 0 && !comp_flip[comp[u]]) flip[u] = true;
if (status[u] == 1 && comp_flip[comp[u]]) flip[u] = true;
}
return consistent;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll N, M;
cin >> N >> M;
vvii E(N, vii());
while (M--) {
int u, v;
char c;
cin >> u >> v >> c;
--u;
--v;
E[u].push_back({v, (c == 'R' ? 1 : 0)});
E[v].push_back({u, (c == 'R' ? 1 : 0)});
}
int boptv = INF, roptv = INF;
vb bflip, rflip;
bool bopt = optimal(N, E, boptv, bflip);
for (int u = 0; u < N; ++u) {
for (size_t i = 0; i < E[u].size(); ++i)
E[u][i].second = 1 - E[u][i].second;
}
bool ropt = optimal(N, E, roptv, rflip);
if (!bopt && !ropt)
cout << -1 << endl;
else {
vb &ans = bflip;
if (!bopt || (ropt && roptv < boptv)) {
ans = rflip;
}
vi ansv;
for (int i = 0; i < N; ++i)
if (ans[i]) ansv.push_back(i + 1);
cout << ansv.size() << endl;
for (size_t i = 0; i < ansv.size(); ++i)
cout << ansv[i] << " \n"[i + 1 == ansv.size()];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, vis[maxn];
vector<int> G[maxn], col[maxn];
vector<int> part[2];
bool dfs(int u, int c, int p) {
if (vis[u] != -1) return vis[u] == p;
vis[u] = p;
part[p].push_back(u);
for (int i = 0; i < G[u].size(); ++i) {
if (!dfs(G[u][i], c, col[u][i] == c ? p : p ^ 1)) return 0;
}
return 1;
}
vector<int> solve(int c) {
vector<int> ans;
memset(vis, -1, sizeof vis);
for (int i = 1; i <= n; ++i) {
if (vis[i] == -1) {
part[0].clear();
part[1].clear();
if (!dfs(i, c, 0)) {
for (int i = 0; i < n + 1; ++i) ans.push_back(-1);
return ans;
}
int f = 0;
if (part[0].size() > part[1].size()) f = 1;
ans.insert(ans.end(), part[f].begin(), part[f].end());
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
char s[2];
scanf("%d%d%s", &a, &b, s);
G[a].push_back(b);
col[a].push_back(s[0] == 'B' ? 0 : 1);
G[b].push_back(a);
col[b].push_back(s[0] == 'B' ? 0 : 1);
}
vector<int> a = solve(0), b = solve(1);
if (a.size() > b.size()) a = b;
if (a.size() > n)
puts("-1");
else {
printf("%d\n", a.size());
for (auto x : a) printf("%d ", x);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4244 4267 4018 4996 4800)
using namespace std;
istream& in = cin;
ostream& out = cout;
template <class T>
void read(T& t) {
for (auto& x : t) in >> x;
}
template <class T>
int sz(T const& t) {
return (int)t.size();
}
int n, m;
vector<vector<int>> edges;
int col;
vector<vector<int>> color;
vector<int> mark, toggled, visited;
bool dfs(int v) {
mark[v] = 1;
visited.push_back(v);
for (int idx = 0; idx < edges[v].size(); ++idx) {
int to = edges[v][idx];
int c = color[v][idx];
if (toggled[v]) c = 1 - c;
if (mark[to]) {
if (toggled[to] != (c != col)) return false;
} else {
toggled[to] = c != col;
if (!dfs(to)) return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
in >> n >> m;
edges.resize(n);
color.resize(n);
for (int i = 0; i < m; ++i) {
int a, b;
char c;
in >> a >> b >> c;
--a;
--b;
edges[a].push_back(b);
edges[b].push_back(a);
color[a].push_back(c == 'R');
color[b].push_back(c == 'R');
}
vector<int> answer[2];
bool answer_found[2] = {true, true};
for (col = 0; col < 2; ++col) {
mark.assign(n, 0);
toggled.assign(n, 0);
for (int i = 0; i < n; ++i) {
if (!mark[i]) {
visited.clear();
toggled[i] = 0;
vector<int> cur1, cur2;
bool found1 = false, found2 = false;
if (dfs(i)) {
found1 = true;
for (int j = 0; j < visited.size(); ++j)
if (toggled[visited[j]]) {
cur1.push_back(visited[j]);
}
}
for (int j = 0; j < visited.size(); ++j)
toggled[visited[j]] = mark[visited[j]] = 0;
visited.clear();
toggled[i] = 1;
if (dfs(i)) {
found2 = 1;
for (int j = 0; j < visited.size(); ++j)
if (toggled[visited[j]]) {
cur2.push_back(visited[j]);
}
}
if (!found1 && !found2) {
answer_found[col] = false;
break;
}
if (found1 && (!found2 || cur1.size() < cur2.size()))
answer[col].insert(answer[col].end(), begin(cur1), end(cur1));
else
answer[col].insert(answer[col].end(), begin(cur2), end(cur2));
}
}
}
if (!answer_found[0] && !answer_found[1])
out << -1;
else {
vector<int> a;
if (answer_found[0] &&
(!answer_found[1] || answer[0].size() < answer[1].size()))
a = answer[0];
else
a = answer[1];
out << a.size() << "\n";
for (int i = 0; i < a.size(); ++i) out << a[i] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<pair<int, char> > > G;
vector<bool> V;
bool contains(const unordered_set<int>& s, int k) {
return s.find(k) != s.end();
}
void dfs(int nr, char color, unordered_set<int>& A, unordered_set<int>& B) {
if (!V[nr]) {
V[nr] = true;
for (int i = 0; i < G[nr].size(); i++) {
int nr1 = G[nr][i].first;
if (G[nr][i].second == color) {
if (contains(A, nr) || contains(A, nr1)) {
A.insert(nr);
A.insert(nr1);
} else {
B.insert(nr);
B.insert(nr1);
}
} else {
if (contains(A, nr) || contains(B, nr1)) {
A.insert(nr);
B.insert(nr1);
} else {
A.insert(nr1);
B.insert(nr);
}
}
dfs(nr1, color, A, B);
}
}
}
bool check(const unordered_set<int>& A, const unordered_set<int>& B) {
for (int i : A) {
if (contains(B, i)) return false;
}
return true;
}
bool makeDFS(char color, unordered_set<int>& res) {
for (int i = 0; i < n; i++) {
unordered_set<int> A;
unordered_set<int> B;
dfs(i, color, A, B);
if (!check(A, B)) return false;
if (A.size() <= B.size())
res.insert(A.begin(), A.end());
else
res.insert(B.begin(), B.end());
}
return true;
}
void print(unordered_set<int>& s) {
cout << s.size() << endl;
for (int i : s) {
cout << i + 1 << " ";
}
cout << endl;
}
int main() {
cin >> n >> m;
G.resize(n);
V.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
char c;
cin >> a >> b >> c;
G[a - 1].push_back(make_pair(b - 1, c));
G[b - 1].push_back(make_pair(a - 1, c));
}
unordered_set<int> minR;
bool red = makeDFS('R', minR);
for (int i = 0; i < n; i++) {
V[i] = false;
}
unordered_set<int> minB;
bool blue = makeDFS('B', minB);
if (!red && !blue)
cout << "-1\n";
else if (red && blue) {
if (minR.size() <= minB.size())
print(minR);
else
print(minB);
} else if (red) {
print(minR);
} else {
print(minB);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int mod = 1000000007;
const int inf = (1 << 30);
const long long infll = (1LL << 60);
int n, m;
vector<pair<int, int> > adj[MAXN];
int vis[MAXN];
vector<int> res[2];
bool fucked = false;
void dfs(int u, int p, int cl) {
if (vis[u]) {
if (vis[u] != p) fucked = true;
return;
}
vis[u] = p;
res[p - 1].push_back(u);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].first;
int c = adj[u][i].second;
if (c == cl)
dfs(v, p, cl);
else
dfs(v, p ^ 3, cl);
}
}
vector<int> ret;
bool solve(int cl) {
memset(vis, 0, sizeof vis);
ret = vector<int>();
for (int i = 1; i <= n; i++) {
fucked = false;
if (vis[i]) continue;
res[0] = res[1] = vector<int>();
dfs(i, 1, cl);
int f = 0;
if (res[1].size() < res[0].size()) f = 1;
if (fucked) return false;
ret.insert(ret.end(), res[f].begin(), res[f].end());
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int u, v, cl;
char s[2];
scanf("%d%d%s", &u, &v, s);
cl = s[0] == 'R' ? 1 : 0;
adj[u].emplace_back(v, cl);
adj[v].emplace_back(u, cl);
}
vector<int> ans = {-1};
if (solve(0)) ans = ret;
if (solve(1)) {
if (ret.size() <= ans.size() || (ans.size() == 1 && ans[0] == -1))
ans = ret;
}
if (ans.size() == 1 && ans[0] == -1)
puts("-1");
else {
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
const int MAXN = 212345;
int n, m, k;
int s[MAXN];
int mrk[MAXN];
int cor[MAXN];
int fodeu[2];
vector<pair<int, int> > adj[MAXN];
vector<int> res[2], cnt[2];
void go(int u, int c) {
;
mrk[u] = 1;
for (pair<int, int> nxt : adj[u]) {
if (mrk[nxt.first]) {
if (nxt.second == c && cor[u] != cor[nxt.first])
fodeu[c] = 1;
else if (nxt.second == 1 - c && cor[u] == cor[nxt.first])
fodeu[c] = 1;
continue;
}
if (nxt.second == c) {
cnt[cor[u]].push_back(nxt.first);
cor[nxt.first] = cor[u];
go(nxt.first, c);
} else {
cor[nxt.first] = 1 - cor[u];
cnt[cor[nxt.first]].push_back(nxt.first);
go(nxt.first, c);
}
}
}
void print(int x) {
printf("%d\n", (int)res[x].size());
for (int u : res[x]) {
printf("%d ", u);
}
printf("\n");
}
int main() {
scanf("%d%d", &n, &m);
for (int a = 0; a < m; a++) {
int u, v;
char c;
scanf("%d %d %c", &u, &v, &c);
adj[u].push_back(pair<int, int>(v, (c == 'B')));
adj[v].push_back(pair<int, int>(u, (c == 'B')));
}
for (int b = 0; b < 2; b++) {
for (int a = 1; a <= n; a++) {
if (mrk[a]) continue;
cor[a] = 0;
cnt[0].push_back(a);
go(a, b);
int i = 1;
if (cnt[0].size() < cnt[1].size()) i = 0;
for (int v : cnt[i]) {
res[b].push_back(v);
}
cnt[0].clear();
cnt[1].clear();
}
for (int a = 1; a <= n; a++) {
cor[a] = 0;
mrk[a] = 0;
}
}
if (fodeu[0] && fodeu[1])
puts("-1");
else if (fodeu[0])
print(1);
else if (fodeu[1])
print(0);
else {
if (res[0].size() < res[1].size())
print(0);
else
print(1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const int N = 1e5 + 4;
vector<int> cur[2];
int vis[N];
vector<pair<int, int> > adjlist[N];
vector<pair<pair<int, int>, int> > edg;
int c[N];
void dfs(int node, int color) {
c[node] = color;
vis[node] = 1;
cur[color].push_back(node);
for (auto i : adjlist[node]) {
int parity = i.second;
int j = i.first;
if (!vis[j]) {
dfs(j, color ^ parity);
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
char type;
cin >> u >> v >> type;
int w = (type == 'B');
edg.push_back(make_pair(make_pair(u, v), w));
adjlist[u].push_back(make_pair(v, w));
adjlist[v].push_back(make_pair(u, w));
}
vector<int> ans;
for (int i = 1; i < n + 1; ++i) {
if (!vis[i]) {
for (int j = 0; j < 2; ++j) cur[j].clear();
dfs(i, 0);
if ((int)cur[0].size() > (int)cur[1].size()) {
swap(cur[0], cur[1]);
}
for (int j : cur[0]) ans.push_back(j);
}
}
int f1 = 1;
for (int i = 0; i < m; ++i) {
int u = edg[i].first.first;
int v = edg[i].first.second;
int w = edg[i].second;
if ((c[u] ^ c[v]) != w) {
f1 = 0;
break;
}
}
for (int i = 0; i < m; ++i) {
edg[i].second ^= 1;
}
for (int i = 1; i < n + 1; ++i) {
for (auto &j : adjlist[i]) {
j.second ^= 1;
}
}
int f2 = 1;
memset(vis, 0, sizeof vis);
memset(c, 0, sizeof c);
vector<int> ans2;
for (int i = 1; i < n + 1; ++i) {
if (!vis[i]) {
for (int j = 0; j < 2; ++j) cur[j].clear();
dfs(i, 0);
if ((int)cur[0].size() > (int)cur[1].size()) {
swap(cur[0], cur[1]);
}
for (int j : cur[0]) ans2.push_back(j);
}
}
for (int i = 0; i < m; ++i) {
int u = edg[i].first.first;
int v = edg[i].first.second;
int w = edg[i].second;
if ((c[u] ^ c[v]) != w) {
f2 = 0;
break;
}
}
if (!f1 && !f2) {
cout << -1 << '\n';
return;
} else if (f1 && f2) {
if ((int)ans.size() > (int)ans2.size()) {
swap(ans, ans2);
}
} else if (f2) {
swap(ans2, ans);
}
cout << (int)ans.size() << '\n';
for (int i : ans) {
cout << i << ' ';
}
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int was[100100][2];
vector<vector<pair<int, char> > > g;
vector<int> res[2];
bool possible[2];
vector<int> now;
void dfs(int v, int p, char ch) {
if (was[v][p]) return;
now.push_back(v);
was[v][p] = 1;
for (int i = (0); i < (g[v].size()); ++i) {
int np = p;
if (g[v][i].second != ch) np ^= 1;
dfs(g[v][i].first, np, ch);
}
}
char s[5];
char all[3];
vector<int> ans;
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = (0); i < (m); ++i) {
int v1, v2;
scanf("%d%d%s", &v1, &v2, s);
v1--;
v2--;
g[v1].push_back(make_pair(v2, s[0]));
g[v2].push_back(make_pair(v1, s[0]));
}
all[0] = 'R';
all[1] = 'B';
for (int it = (0); it < (2); ++it) {
memset((was), (0), sizeof(was));
possible[it] = true;
for (int i = (0); i < (n); ++i) {
if ((was[i][0] == 0) && (was[i][1] == 0)) {
now.clear();
dfs(i, 0, all[it]);
bool ok = true;
int cnt0 = 0;
int cnt1 = 0;
for (int j = (0); j < (now.size()); ++j) {
int v = now[j];
if (was[v][0])
cnt0++;
else
cnt1++;
if ((was[v][0]) && (was[v][1])) {
ok = false;
break;
}
}
if (!ok) {
possible[it] = false;
break;
}
for (int j = (0); j < (now.size()); ++j) {
int v = now[j];
if (was[v][0] && (cnt0 < cnt1)) res[it].push_back(v);
if (was[v][1] && (cnt0 >= cnt1)) res[it].push_back(v);
}
}
}
}
if ((!possible[0]) && (!possible[1])) {
cout << -1 << endl;
return 0;
}
if ((possible[0]) &&
((possible[1] == false) || (res[0].size() <= res[1].size())))
ans = res[0];
else
ans = res[1];
printf("%d\n", ans.size());
for (int i = (0); i < (ans.size()); ++i) {
if (i) printf(" ");
printf("%d", ans[i] + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = (int)1e9 + 9;
const int MAXN = (int)3e5 + 7;
int n, m;
int a[MAXN];
int b[MAXN];
int c[MAXN];
bool used[MAXN];
int comp[MAXN];
int on[MAXN];
vector<int> g[MAXN];
vector<int> gd[MAXN];
vector<int> grev[MAXN];
int t(int x) { return x + x; }
int first(int x) { return (x + x) ^ 1; }
vector<int> order;
void dfs1(int v) {
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) dfs1(to);
}
order.push_back(v);
}
void dfs2(int v, int cl) {
comp[v] = cl;
for (size_t i = 0; i < grev[v].size(); ++i) {
int to = grev[v][i];
if (comp[to] == -1) dfs2(to, cl);
}
}
int cc, sz;
vector<int> li;
void go(int x) {
used[x] = 1;
if (on[x]) cc++;
sz++;
li.push_back(x);
for (auto to : gd[x])
if (!used[to]) go(to);
}
vector<int> solve(int target) {
for (int i = 0; i < n + n; i++) {
g[i].clear();
grev[i].clear();
}
order.clear();
for (int i = 1; i <= m; i++) {
if (c[i] == target) {
g[first(a[i])].push_back(first(b[i]));
g[t(b[i])].push_back(t(a[i]));
g[t(a[i])].push_back(t(b[i]));
g[first(b[i])].push_back(first(a[i]));
} else {
g[first(a[i])].push_back(t(b[i]));
g[first(b[i])].push_back(t(a[i]));
g[t(a[i])].push_back(first(b[i]));
g[t(b[i])].push_back(first(a[i]));
}
}
for (int i = 0; i < n + n; i++) {
for (auto j : g[i]) {
grev[j].push_back(i);
}
}
memset(used, 0, sizeof used);
for (int i = 0; i < n + n; i++) {
if (!used[i]) dfs1(i);
}
memset(comp, -1, sizeof comp);
for (int i = 0, j = 0; i < n + n; i++) {
int v = order[n + n - i - 1];
if (comp[v] == -1) dfs2(v, j++);
}
vector<int> no_sol;
for (int i = 0; i < n + n; i++) no_sol.push_back(i);
for (int i = 0; i < n; i++) {
if (comp[i + i] == comp[i + i + 1]) {
return no_sol;
}
}
memset(on, 0, sizeof on);
vector<int> cnt;
for (int i = 0; i < n; i++) {
if (comp[i + i] > comp[i + i + 1]) on[i] = 1;
}
memset(used, 0, sizeof used);
for (int i = 0; i < n; i++) {
if (!used[i]) {
cc = 0;
sz = 0;
li.clear();
go(i);
int inv = 0;
if (sz - cc < cc) {
inv = 1;
}
for (auto it : li) {
if (on[it] ^ inv) cnt.push_back(it);
}
}
}
return cnt;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
char ch;
scanf("\n%d %d %c", &a[i], &b[i], &ch);
a[i]--;
b[i]--;
c[i] = (ch == 'R');
}
for (int i = 1; i <= m; i++) {
gd[a[i]].push_back(b[i]);
gd[b[i]].push_back(a[i]);
}
vector<int> l = solve(0);
vector<int> r = solve(1);
if (l.size() < r.size()) swap(l, r);
if (r.size() == n + n) {
cout << -1;
return 0;
}
printf("%d\n", r.size());
for (auto it : r) printf("%d ", it + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1E9;
const int MAXN = 100010;
int par[MAXN], sub[MAXN];
int neg[MAXN];
void Init() {
for (int i = 0; i < MAXN; ++i) par[i] = i, sub[i] = 1, neg[i] = -1;
}
int GetPar(int vr) { return par[vr] == vr ? vr : par[vr] = GetPar(par[vr]); }
int Merge(int a, int b) {
if (a == -1 || b == -1) return a == -1 ? b : a;
a = GetPar(a);
b = GetPar(b);
if (a != b) par[a] = b, sub[b] += sub[a];
return b;
}
bool InOne(int a, int b) {
if (a == -1 || b == -1) return false;
return GetPar(a) == GetPar(b);
}
int Neg(int vr) { return vr == -1 ? -1 : neg[vr]; }
void SetNeg(int a, int b) {
if (a != -1) neg[a] = b;
if (b != -1) neg[b] = a;
}
bool Same(int a, int b) {
a = GetPar(a), b = GetPar(b);
int ap = Neg(a), bp = Neg(b);
if (InOne(a, bp) || InOne(b, ap)) return false;
int x = Merge(a, b);
int y = Merge(ap, bp);
SetNeg(x, y);
return true;
}
bool Diff(int a, int bp) {
a = GetPar(a), bp = GetPar(bp);
int ap = Neg(a), b = Neg(bp);
if (InOne(a, bp) || InOne(b, ap)) return false;
int x = Merge(a, b);
int y = Merge(ap, bp);
SetNeg(x, y);
return true;
}
int n, m;
vector<pair<int, int> > edj;
vector<char> col;
int Steps(char type) {
Init();
for (int i = 0; i < m; ++i)
if (col[i] == type) {
if (!Same(edj[i].first, edj[i].second)) return oo;
} else {
if (!Diff(edj[i].first, edj[i].second)) return oo;
}
int sum = 0;
for (int i = 0; i < n; ++i)
if (par[i] == i) {
int a = i, b = Neg(i);
if (a > b) {
int as = sub[a];
int bs = (b != -1) ? sub[b] : 0;
sum += min(as, bs);
}
}
return sum;
}
int main() {
scanf("%d%d", &n, &m);
char tmp[5];
edj.resize(m), col.resize(m);
for (int i = 0; i < m; ++i)
scanf("%d%d%s", &edj[i].first, &edj[i].second, tmp), --edj[i].first,
--edj[i].second, col[i] = tmp[0];
int best = oo, cur;
char btype = '?';
cur = Steps('B');
if (cur < best) best = cur, btype = 'B';
cur = Steps('R');
if (cur < best) best = cur, btype = 'R';
if (best == oo)
puts("-1");
else {
printf("%d\n", best);
Steps(btype);
set<int> act;
for (int i = 0; i < n; ++i)
if (par[i] == i) {
int a = i, b = Neg(i);
if (a > b) {
int as = sub[a];
int bs = (b != -1) ? sub[b] : 0;
if (as > bs)
act.insert(b);
else
act.insert(a);
}
}
vector<int> ans;
for (int i = 0; i < n; ++i)
if (act.count(GetPar(i))) ans.push_back(i);
for (int i = 0; i < ((int)(ans).size()); ++i)
printf("%d%c", ans[i] + 1, (i + 1 == ((int)(ans).size())) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:667772160")
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
vector<int> graph[100000 + 7], ans, color[100000 + 7], part[3];
int visit[100000 + 7];
bool dfs(int u, int grp, int cl) {
if (visit[u]) return (bool)(visit[u] == grp);
part[grp].push_back(u);
visit[u] = grp;
int v, cr;
for (int i = 0; i < graph[u].size(); i++) {
v = graph[u][i];
cr = color[u][i];
if (!dfs(v, cr == cl ? grp : grp ^ 3, cl)) return 0;
}
return true;
}
bool cal(int cl, int n) {
memset(visit, 0, sizeof(visit));
ans.clear();
for (int i = 1; i <= n; i++) {
if (visit[i]) continue;
part[1].clear();
part[2].clear();
if (!dfs(i, 1, cl)) return 0;
if (part[1].size() < part[2].size())
ans.insert(ans.end(), part[1].begin(), part[1].end());
else
ans.insert(ans.end(), part[2].begin(), part[2].end());
}
return true;
}
int main() {
int n, m, u, v;
char ch;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %c", &u, &v, &ch);
graph[u].push_back(v);
graph[v].push_back(u);
int col = (ch == 'B');
color[u].push_back(col);
color[v].push_back(col);
}
vector<int> res;
bool isok = true;
if (cal(1, n)) {
isok = false;
res = ans;
}
if (cal(0, n)) {
if (isok or ans.size() < res.size()) res = ans;
isok = false;
}
if (!isok) {
deb(res.size());
for (int i = 0; i < res.size(); i++) {
if (i) printf(" ");
printf("%d", res[i]);
}
printf("\n");
} else
deb(-1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100000;
int n, vis[MX];
vector<pair<int, char>> G[MX];
vector<int> part[3];
bool dfs(int v, int p, char c) {
if (vis[v] != 0) {
return vis[v] == p;
}
vis[v] = p;
part[p].push_back(v);
for (auto x : G[v]) {
if (dfs(x.first, x.second == c ? p : p ^ 3, c) == false) return false;
}
return true;
}
vector<int> solve(char c) {
memset(vis, 0, sizeof vis);
vector<int> ans;
for (int i = 0; i < n; i++)
if (vis[i] == 0) {
part[1].clear();
part[2].clear();
if (dfs(i, 1, c) == false) {
for (int j = 0; j < n + 1; j++) ans.push_back(-1);
return ans;
}
int f = 1;
if (part[2].size() < part[1].size()) f = 2;
ans.insert(ans.end(), part[f].begin(), part[f].end());
}
return ans;
}
int main() {
int m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
char c;
scanf("%d %d %c", &u, &v, &c);
u--;
v--;
G[u].emplace_back(v, c);
G[v].emplace_back(u, c);
}
auto f = solve('R');
auto g = solve('B');
if (g.size() < f.size()) f = g;
if (f.size() > n) {
printf("-1\n");
return 0;
}
printf("%d\n", (int)f.size());
for (int x : f) printf("%d ", x + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "sz = " << vc.size() << endl << "[";
for (const T& v : vc) o << v << ",";
o << "]";
return o;
}
int N, M;
vector<pair<int, int> > G[100000];
bool vis[100000];
bool f[100000];
vector<int> ad;
bool dfs(int v, int p, bool B) {
vis[v] = 1;
for (pair<int, int> e : G[v]) {
int u = e.first;
if (u == p) continue;
if (vis[u]) {
if ((e.second ^ f[u] ^ f[v]) != B) return false;
continue;
}
if ((e.second ^ f[v]) != B) {
ad.push_back(u);
f[u] = 1;
}
if (!dfs(u, v, B)) return false;
}
return true;
}
void dfss(vector<int>& vs, int v) {
vis[v] = 1;
vs.push_back(v);
for (pair<int, int> e : G[v]) {
int u = e.first;
if (!vis[u]) dfss(vs, u);
}
}
int main() {
cin >> N >> M;
for (int i = 0; i < (int)(M); i++) {
int a, b;
char c;
cin >> a >> b >> c;
a--, b--;
G[a].push_back(pair<int, int>(b, c == 'B'));
G[b].push_back(pair<int, int>(a, c == 'B'));
}
bool ok1 = 1, ok2 = 1;
vector<int> ans1, ans2;
for (int i = 0; i < (int)(N); i++)
if (!vis[i]) {
ad.clear();
vector<int> t;
bool ok = 0;
vector<int> vs;
dfss(vs, i);
for (int v : vs) vis[v] = 0;
if (dfs(i, -1, 0) && (!ok || t.size() > ad.size())) t = ad, ok = 1;
ad.clear();
for (int v : vs) vis[v] = 0, f[v] = 0;
f[i] = 1, ad.push_back(i);
if (dfs(i, -1, 0) && (!ok || t.size() > ad.size())) t = ad, ok = 1;
ad.clear();
for (int v : vs) vis[v] = 0, f[v] = 0;
if (ok) {
for (int a : t) ans1.push_back(a);
} else {
ok1 = 0;
}
ok = 0;
t.clear();
if (dfs(i, -1, 1) && (!ok || t.size() > ad.size())) t = ad, ok = 1;
ad.clear();
for (int v : vs) vis[v] = 0, f[v] = 0;
f[i] = 1, ad.push_back(i);
if (dfs(i, -1, 1) && (!ok || t.size() > ad.size())) t = ad, ok = 1;
ad.clear();
for (int v : vs) vis[v] = 1;
if (ok) {
for (int a : t) ans2.push_back(a);
} else {
ok2 = 0;
}
}
if (!ok1 && !ok2) {
puts("-1");
return 0;
}
vector<int> ans;
if (ok1) ans = ans1;
if (!ok1 && ok2) ans = ans2;
if (ok1 && ok2) {
if (ans1.size() > ans2.size()) ans = ans2;
}
cout << ans.size() << endl;
for (int a : ans) cout << a + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<pair<int, char> > G[N];
vector<int> part[3];
int vis[N], n, m;
bool dfs(int x, int p, char ch) {
if (vis[x]) return vis[x] == p;
vis[x] = p;
part[p].push_back(x);
for (auto i : G[x]) {
if (dfs(i.first, i.second == ch ? p : p ^ 3, ch) == false) return false;
}
return true;
}
vector<int> solve(char ch) {
memset(vis, 0, sizeof vis);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
part[1].clear();
part[2].clear();
if (dfs(i, 1, ch) == false) {
for (int i = 1; i <= n + 1; i++) ans.push_back(-1);
return ans;
}
int flag = 1;
if (part[2].size() < part[1].size()) flag = 2;
ans.insert(ans.end(), part[flag].begin(), part[flag].end());
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
char str[2];
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d%s", &u, &v, str);
G[u].push_back(make_pair(v, str[0]));
G[v].push_back(make_pair(u, str[0]));
}
auto res1 = solve('R'), res2 = solve('B');
if (res2.size() < res1.size()) res1 = res2;
if (res1.size() > n) return puts("-1") & 0;
printf("%d\n", res1.size());
for (auto i : res1) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
char c;
int u, v;
edge(int _u, int _v, char _c) {
c = _c;
u = _u;
v = _v;
}
};
int n;
vector<vector<edge> > graph;
vector<int> used;
vector<bool> col;
vector<int> last_comp;
int dfs(int u, char to, bool do_color, int cur_used) {
used[u] = cur_used;
int ans = do_color;
col[u] = do_color;
last_comp.push_back(u);
for (edge e : graph[u]) {
if (used[e.v] != cur_used) {
int t = dfs(e.v, to, do_color == (e.c == to), cur_used);
if (t == 1791791791) return 1791791791;
ans += t;
} else if (col[e.v] != (do_color == (e.c == to))) {
return 1791791791;
}
}
return ans;
}
int gl_cur_used = 0;
vector<bool> in_comp;
int get_min(char to) {
in_comp.clear();
int ans = 0;
gl_cur_used++;
for (int i = 0; i < n; i++) {
if (used[i] != gl_cur_used) {
int a1 = dfs(i, to, false, gl_cur_used);
for (int u : last_comp) used[u] = -1;
last_comp.clear();
int a2 = dfs(i, to, true, gl_cur_used);
last_comp.clear();
if (a1 == a2 && a2 == 1791791791)
return 1791791791;
else if (a1 < a2) {
in_comp.push_back(false);
ans += a1;
} else {
in_comp.push_back(true);
ans += a2;
}
}
}
return ans;
}
void build_ans(char to) {
get_min(to);
gl_cur_used++;
int j = 0;
for (int i = 0; i < n; i++) {
if (used[i] != gl_cur_used) {
dfs(i, to, in_comp[j], gl_cur_used);
j++;
}
}
}
int main() {
int m;
cin >> n >> m;
graph.resize(n);
for (int i = 0; i < m; i++) {
int u, v;
char c;
cin >> u >> v >> c;
u--;
v--;
graph[u].push_back(edge(u, v, c));
graph[v].push_back(edge(v, u, c));
}
used.resize(n, -1);
col.resize(n);
int a1 = get_min('B'), a2 = get_min('R');
if (a1 == a2 && a2 == 1791791791) {
cout << -1 << endl;
return 0;
}
if (a1 < a2)
build_ans('B');
else
build_ans('R');
cout << min(a1, a2) << endl;
for (int i = 0; i < n; i++)
if (col[i]) cout << i + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void getre() {
int x = 0;
printf("%d\n", 1 / x);
}
void gettle() {
int res = 1;
while (1) res <<= 1;
printf("%d\n", res);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
template <typename N>
inline int sgn(N a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gs(char *s) { scanf("%s", s); }
inline void gc(char &c) {
while ((c = getchar()) > 126 || c < 33)
;
}
inline void pc(char c) { putchar(c); }
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double pi = 3.14159265358979323846264338327950288L;
const double eps = 1e-6;
const int mo = 1;
int qp(int a, long long b) {
int n = 1;
do {
if (b & 1) n = 1ll * n * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return n;
}
struct ed {
int u, v, d;
void read() {
gn(u);
gn(v);
char c;
gc(c);
if (c == 'B')
d = 0;
else
d = 1;
}
} e[111111];
int n, m;
int mi = inf;
vector<int> an;
int fa[322222];
int xa[222222], xb[222222];
int gf(int x) { return x == fa[x] ? x : fa[x] = gf(fa[x]); }
void un(int x, int y) {
x = gf(x);
y = gf(y);
if (x != y) {
fa[x] = y;
}
}
int ne[222222];
void work(int d) {
memset((xa), (0), sizeof(xa));
memset((xb), (0), sizeof(xb));
for (int i = (1), _ed = (3 * n + 1); i < _ed; i++) fa[i] = i;
for (int i = (1), _ed = (m + 1); i < _ed; i++) {
int u = e[i].u, v = e[i].v;
if (d == e[i].d) {
un(u, v);
un(u + n, v + n);
} else {
un(u, v + n);
un(v, u + n);
}
un(u + 2 * n, v + 2 * n);
}
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (gf(i) == gf(i + n)) return;
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
int r = gf(i + 2 * n) - 2 * n;
if (gf(i) == gf(r))
xa[r]++;
else
xb[r]++;
}
int su = 0;
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
su += min(xa[i], xb[i]);
ne[i] = xa[i] < xb[i];
}
if (su < mi) {
mi = su;
an.clear();
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
int r = gf(i + 2 * n) - 2 * n;
if ((gf(i) == gf(r)) == ne[r]) an.push_back(i);
}
}
}
int main() {
gn(n);
gn(m);
for (int i = (1), _ed = (m + 1); i < _ed; i++) e[i].read();
for (int d = 0; d <= 1; d++) work(d);
if (mi == inf)
printf("-1\n");
else {
printf("%d\n", mi);
for (int i = (0), _ed = (((int)(an).size())); i < _ed; i++)
printf("%d ", an[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int _N = 100010;
const int _M = _N << 1;
const int INF = 1000000000;
int n, m, numE, Fir[_N];
int ed[_M], tp[_M], Next[_M];
void addE(int x, int y, int z) {
ed[++numE] = y, tp[numE] = z, Next[numE] = Fir[x], Fir[x] = numE;
ed[++numE] = x, tp[numE] = z, Next[numE] = Fir[y], Fir[y] = numE;
}
int fa[_N], sta[_N], save[_N], numZ;
int re[2][_N], now, res[2];
void dfs(int u) {
save[++save[0]] = u, numZ += sta[u];
for (int e = Fir[u]; e; e = Next[e]) {
int v = ed[e];
if (fa[v]) continue;
fa[v] = u, sta[v] = sta[u] ^ tp[e], dfs(v);
}
}
void solve() {
for (int i = 1; i <= n; i++) fa[i] = 0;
for (int i = 1; i <= n; i++)
if (!fa[i]) {
fa[i] = -1, sta[i] = 1, numZ = save[0] = 0, dfs(i);
for (int j = 1; j <= save[0]; j++)
for (int e = Fir[save[j]]; e; e = Next[e])
if (tp[e] != sta[save[j]] ^ sta[ed[e]]) {
res[now] = INF;
return;
}
if (numZ > save[0] - numZ)
for (int j = 1; j <= save[0]; j++) sta[save[j]] ^= 1;
}
for (int i = 1; i <= n; i++) re[now][i] = sta[i], res[now] += sta[i];
}
int main() {
scanf("%d%d", &n, &m);
static char s[5];
static int x, y;
for (int i = 1; i <= m; i++)
scanf("%d%d%s", &x, &y, s), addE(x, y, s[0] == 'B');
solve();
for (int i = 1; i <= n; i++)
for (int j = Fir[i]; j; j = Next[j]) tp[j] ^= 1;
++now, solve();
if (res[0] < res[1]) now = 0;
if (res[now] == INF) {
puts("-1");
return 0;
}
printf("%d\n", res[now]);
for (int i = 1; i <= n; i++)
if (re[now][i]) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
int n, m;
vector<vector<int> > g;
int a[N], b[N], comp[N], cmp, ans[N];
char clr[N];
char vis[N];
bool isD[N];
int B, W;
bool DFS(int u, bool clr) {
if (vis[u] != -1) return clr == vis[u];
comp[u] = cmp;
vis[u] = clr;
if (!isD[u]) {
B += clr;
W += !clr;
}
for (int i = 0; i < g[u].size(); ++i)
if (!DFS(g[u][i], !clr)) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d %c", &a[i], &b[i], &clr[i]);
--a[i];
--b[i];
clr[i] = clr[i] == 'R';
}
int res = 1e9;
vector<int> sol;
for (int it = 0; it < 2; ++it) {
memset(vis, -1, sizeof(vis));
memset(isD, 0, sizeof(isD));
g.clear();
g.resize(n);
for (int i = 0; i < m; ++i) {
clr[i] = !clr[i];
if (clr[i]) {
int x = g.size();
g.push_back(vector<int>());
isD[x] = true;
g[a[i]].push_back(x);
g[x].push_back(a[i]);
g[b[i]].push_back(x);
g[x].push_back(b[i]);
} else {
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
}
int cur = 0;
cmp = 0;
for (int i = 0; i < g.size(); ++i)
if (vis[i] == -1) {
B = W = 0;
if (!DFS(i, 0)) {
cur = 1e9;
break;
}
cur += min(B, W);
ans[cmp] = B <= W;
++cmp;
}
if (res > cur) {
res = cur;
sol.clear();
for (int i = 0; i < n; ++i)
if (vis[i] == ans[comp[i]]) sol.push_back(i);
assert(sol.size() == res);
}
}
if (res > 1e8) res = -1;
printf("%d\n", res);
if (res != -1) {
for (int i = 0; i < sol.size(); ++i)
printf("%s%d", i ? " " : "", sol[i] + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x7fffffff;
const long long linf = ~(1LL << 63);
template <typename T>
inline T gcd(T a, T b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename C>
inline void sort(C& v) {
sort(v.begin(), v.end());
}
inline void println(int u) { printf("%d\n", u); }
inline void printsp(int u) { printf("%d ", u); }
const int maxn = 100109;
int n, m;
struct edge {
int to;
char c;
};
vector<edge> E[maxn];
void addedge(int u, int v, char c) {
E[u].push_back({v, c});
E[v].push_back({u, c});
}
bool vis[maxn];
bool to_recolor[maxn];
int recolor = 0;
int cnt = 0, p = 0;
int vv[maxn];
bool find_color(int s, char c) {
cnt++;
vv[p++] = s;
vis[s] = true;
bool ok = true;
for (auto& ed : E[s]) {
int to = ed.to;
if (vis[to]) {
if (ed.c == c) {
if (to_recolor[s] != to_recolor[to]) return false;
} else {
if (to_recolor[s] == to_recolor[to]) return false;
}
} else {
to_recolor[to] = ed.c == c ? to_recolor[s] : !to_recolor[s];
recolor += to_recolor[to] ? 1 : 0;
ok = ok && find_color(to, c);
}
if (!ok) break;
}
return ok;
}
map<char, vector<int> > seq;
int single_point = 0;
int color_to(char c) {
memset(vis, 0, sizeof vis);
memset(to_recolor, 0, sizeof to_recolor);
recolor = 0;
vector<int>& sq = seq[c];
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (E[i].size() == 0) {
single_point++;
continue;
}
recolor = 0;
cnt = 0;
p = 0;
if (!find_color(i, c)) return -1;
if (recolor < cnt - recolor) {
for (int i = 0; i < p; i++) {
if (to_recolor[vv[i]]) {
sq.push_back(vv[i]);
}
}
ans += recolor;
} else {
for (int i = 0; i < p; i++) {
if (!to_recolor[vv[i]]) {
sq.push_back(vv[i]);
}
}
ans += cnt - recolor;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
int u, v;
char c;
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
addedge(u, v, c);
}
int red = color_to('R');
int blue = color_to('B');
if (red == -1 && blue == -1) {
cout << "-1" << endl;
} else {
char aa;
int ans = 9999999;
if (red != -1) {
if (ans > red) {
aa = 'R';
ans = red;
}
}
if (blue != -1) {
if (ans > blue) {
aa = 'B';
ans = blue;
}
}
cout << ans << endl;
for (auto x : seq[aa]) {
cout << x << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int infty = 123456789;
int n, m;
vector<pair<int, int> > ne[100005];
int ans[2];
int vis[2][100005];
const char *s = "";
int dfs(int v, int as, int t) {
int ret = as;
vis[t][v] = as;
for (int i = 0; i < ne[v].size() && ret < infty; i++) {
int s = ne[v][i].first, c = ne[v][i].second;
if (vis[t][s] == -1) {
if (c == t)
ret += dfs(s, as, t);
else
ret += dfs(s, !as, t);
} else {
if (c == t && vis[t][s] != vis[t][v])
return infty;
else if (c != t && vis[t][s] == vis[t][v])
return infty;
}
}
return (ret < infty ? ret : infty);
}
void clear(int v, int t) {
vis[t][v] = -1;
for (int i = 0; i < ne[v].size(); i++) {
int s = ne[v][i].first;
if (vis[t][s] != -1) clear(s, t);
}
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
char c;
scanf("%d %d %c\n", &u, &v, &c);
u--;
v--;
ne[u].push_back(make_pair((v), (c == 'B')));
ne[v].push_back(make_pair((u), (c == 'B')));
}
for (int t = 0; t < 2; t++) {
for (int i = 0; i < n; i++) vis[t][i] = -1;
ans[t] = 0;
for (int i = 0; i < n; i++) {
if (vis[t][i] == -1) {
int mini = infty, mini_m;
for (int m = 0; m < 2; m++) {
int tmp = dfs(i, m, t);
if (tmp < mini) {
mini = tmp;
mini_m = m;
}
clear(i, t);
}
if (mini == infty) {
ans[t] = infty;
break;
}
ans[t] += dfs(i, mini_m, t);
}
}
}
int best_t;
if (ans[0] <= ans[1])
best_t = 0;
else
best_t = 1;
if (ans[best_t] == infty) {
printf("-1\n");
return 0;
}
printf("%d\n", ans[best_t]);
for (int i = 0; i < n; i++) {
if (vis[best_t][i]) {
printf("%s%d", s, i + 1);
s = " ";
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int> > v[100007];
int used[100007];
vector<int> u[2 * 100007];
bool dfs(int vertex, int x, int y, int val) {
int i, sz;
sz = v[vertex].size();
if (used[vertex] == 0) {
used[vertex] = x;
}
u[used[vertex]].push_back(vertex);
for (i = 0; i < sz; i++) {
int h = v[vertex][i].first;
if (v[vertex][i].second == val) {
if (used[h] != 0 && used[h] != used[vertex]) {
return false;
}
if (used[h] != 0) {
continue;
}
used[h] = used[vertex];
bool g = dfs(h, x, y, val);
if (g == false) {
return false;
}
} else {
if (used[h] == used[vertex]) {
return false;
}
if (used[h] != 0) {
continue;
}
used[h] = (x + y - used[vertex]);
bool g = dfs(h, x, y, val);
if (g == false) {
return false;
}
}
}
return true;
}
vector<int> pos(int val) {
vector<int> ret;
vector<int> bait;
ret.clear();
bait.clear();
int i, j;
for (i = 1; i <= 2 * n; i++) {
bait.push_back(1);
}
for (i = 1; i <= n; i++) {
used[i] = 0;
}
for (i = 1; i <= 2 * n; i++) {
u[i].clear();
}
int id = 1;
for (i = 1; i <= n; i++) {
if (used[i] == 0) {
if (dfs(i, id, id + 1, val) == false) {
return bait;
}
id += 2;
}
}
id--;
id /= 2;
for (i = 1; i <= id; i++) {
if (u[2 * i - 1].size() == 0 && u[2 * i].size() == 0) {
continue;
}
if (u[2 * i - 1].size() > u[2 * i].size()) {
swap(u[2 * i - 1], u[2 * i]);
}
int sz = u[2 * i - 1].size();
for (j = 0; j < sz; j++) {
ret.push_back(u[2 * i - 1][j]);
}
}
return ret;
}
void input() {
cin >> n >> k;
int x, y, z;
char c;
int i;
for (i = 1; i <= k; i++) {
cin >> x >> y >> c;
if (c == 'R') {
z = 0;
} else {
z = 1;
}
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
}
}
void solve() {
int i, sz;
vector<int> v1, v2;
v1 = pos(0);
v2 = pos(1);
if (v1.size() > v2.size()) {
swap(v1, v2);
}
sz = v1.size();
if (sz > n) {
printf("-1\n");
return;
}
printf("%d\n", sz);
for (i = 0; i < sz; i++) {
printf("%d", v1[i]);
if (i == (sz - 1)) {
printf("\n");
} else {
printf(" ");
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
struct Ans {
bool ok;
vector<int> s;
bool operator<(const Ans &P) const {
if (ok == P.ok) return s.size() < P.s.size();
return ok > P.ok;
}
};
int n, m;
struct Edge {
int v, nxt, z;
} E[MX << 2];
int Head[MX], erear;
void edge_init() {
erear = 0;
memset(Head, -1, sizeof(Head));
}
void edge_add(int u, int v, int z) {
E[erear].v = v;
E[erear].z = z;
E[erear].nxt = Head[u];
Head[u] = erear++;
}
int col[MX], vis[MX];
Ans deal(int x, int u, int c) {
Ans ret;
ret.ok = true;
vector<int> p;
queue<int> Q;
Q.push(u);
col[u] = c;
vis[u] = 1;
p.push_back(u);
while (!Q.empty()) {
u = Q.front();
Q.pop();
if (col[u]) ret.s.push_back(u);
for (int i = Head[u]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (vis[v] && (col[u] ^ col[v] ^ E[i].z) != x) {
ret.ok = false;
break;
}
if (!vis[v]) {
col[v] = E[i].z ^ col[u] ^ x;
vis[v] = 1;
Q.push(v);
p.push_back(v);
}
}
}
if (c == 0) {
for (int i = 0; i < p.size(); i++) {
vis[p[i]] = 0;
}
}
return ret;
}
Ans solve(int x) {
Ans ret, temp;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
temp = min(deal(x, i, 1), deal(x, i, 0));
if (!temp.ok) {
ret.ok = false;
return ret;
}
for (int j = 0; j < temp.s.size(); j++) {
ret.s.push_back(temp.s[j]);
}
}
ret.ok = true;
return ret;
}
int main() {
edge_init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
char op[10];
scanf("%d%d%s", &u, &v, op);
int z = op[0] == 'R' ? 1 : 0;
edge_add(u, v, z);
edge_add(v, u, z);
}
Ans ans = min(solve(0), solve(1));
if (!ans.ok)
printf("-1\n");
else {
int sz = ans.s.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) {
printf("%d%c", ans.s[i], i == sz - 1 ? '\n' : ' ');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
struct Edge {
int u, v;
bool color;
};
int dsu_find(vector<int>& dsu, int u) {
if (dsu[u] == u) return u;
return dsu[u] = dsu_find(dsu, dsu[u]);
}
void dsu_merge(vector<int>& dsu, int a, int b) {
a = dsu_find(dsu, a);
b = dsu_find(dsu, b);
dsu[a] = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<Edge> edges(m);
for (int i = 0; i < m; i++) {
cin >> edges[i].u >> edges[i].v;
--edges[i].u, --edges[i].v;
string c;
cin >> c;
edges[i].color = (c == "R");
}
bool same = true, other = false;
vector<int> moves;
bool found = false;
for (int it = 0; it <= 1; it++) {
swap(same, other);
vector<int> target_moves;
vector<int> dsu(n);
for (int i = 0; i < n; i++) dsu[i] = i;
for (const auto& e : edges) {
if (e.color == same) {
dsu_merge(dsu, e.u, e.v);
}
}
bool fail = false;
vector<int> weight(n, 0);
vector<vector<int>> new_edges(n);
for (int i = 0; i < n; i++) ++weight[dsu_find(dsu, i)];
for (const auto& e : edges) {
if (e.color == other) {
if (dsu_find(dsu, e.u) == dsu_find(dsu, e.v)) {
fail = true;
}
int u = dsu_find(dsu, e.u);
int v = dsu_find(dsu, e.v);
if (u != v) {
new_edges[u].push_back(v);
new_edges[v].push_back(u);
}
}
}
if (fail) continue;
vector<int> colors(n, -1);
vector<int> visited;
std::function<void(int, int)> dfs;
dfs = [&](int u, int c) {
visited.push_back(u);
colors[u] = c;
for (int v : new_edges[u]) {
if (colors[v] != -1 && colors[v] != (1 - c)) fail = true;
if (colors[v] == -1) {
dfs(v, 1 - c);
}
}
};
vector<bool> target_comps(n, false);
for (int i = 0; i < n; i++) {
if (colors[i] == -1) {
visited.clear();
dfs(i, 0);
int zero = 0, one = 0;
for (int u : visited) {
if (colors[u] == 0)
zero += weight[u];
else
one += weight[u];
}
int target = (zero < one) ? 0 : 1;
for (int u : visited) {
if (colors[u] == target) target_comps[u] = true;
}
}
}
if (fail) continue;
for (int i = 0; i < n; i++) {
if (target_comps[dsu_find(dsu, i)]) {
target_moves.push_back(i + 1);
}
}
if (!found || moves.size() > target_moves.size()) moves = target_moves;
found = true;
}
if (found) {
cout << moves.size() << endl;
for (int u : moves) cout << u << " ";
cout << endl;
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void bug() { cout << " " << endl; }
template <class T>
void bug(T a) {
cout << a << " ";
}
template <class T>
void bug(T* a, int n) {
for (int i = 0; i < (n); i++) bug(a[i]);
}
int n, m;
vector<pair<pair<int, int>, bool> > e;
int ans = 1000000000;
vector<int> vs;
int fa[111111], size[111111];
int find(int u) {
if (fa[u] == u)
return u;
else
return fa[u] = find(fa[u]);
}
void merge(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
if (size[u] > size[v]) {
size[u] += size[v];
fa[v] = u;
} else {
size[v] += size[u];
fa[u] = v;
}
}
vector<int> g[111111];
int vis[111111];
void go(bool b) {
for (int i = 0; i < (n); i++) g[i].clear();
memset(vis, -1, sizeof(vis));
for (int i = 0; i < (n); i++) {
fa[i] = i;
size[i] = 1;
}
for (int i = 0; i < (m); i++) {
int u = e[i].first.first;
int v = e[i].first.second;
bool bb = e[i].second;
if (bb == b) {
merge(u, v);
}
}
for (int i = 0; i < (m); i++) {
int u = e[i].first.first;
int v = e[i].first.second;
bool bb = e[i].second;
if (bb != b) {
u = find(u);
v = find(v);
g[u].push_back(v);
g[v].push_back(u);
}
}
int ret = 0;
vector<int> vv;
for (int i = 0; i < (n); i++)
if (find(i) == i && vis[i] == -1) {
queue<int> q;
q.push(i);
vis[i] = 0;
int zero = size[i], one = 0;
vector<int> zs, os;
zs.push_back(i);
while (q.size() > 0) {
int u = q.front();
q.pop();
for (int v : g[u]) {
if (vis[v] != -1) {
if (vis[v] != (1 - vis[u])) return;
} else {
vis[v] = (1 - vis[u]);
if (vis[v] == 0) {
zero += size[v];
zs.push_back(v);
} else {
one += size[v];
os.push_back(v);
}
q.push(v);
}
}
}
if (zero < one) {
ret += zero;
for (int i = 0; i < (zs.size()); i++) vv.push_back(zs[i]);
} else {
ret += one;
for (int i = 0; i < (os.size()); i++) vv.push_back(os[i]);
}
}
if (ans > ret) {
ans = ret;
set<int> s;
for (int i = 0; i < (vv.size()); i++) s.insert(vv[i]);
vs.clear();
for (int i = 0; i < (n); i++)
if (s.find(find(i)) != s.end()) vs.push_back(i);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int u, v;
char c;
cin >> u >> v >> c;
u--;
v--;
bool b = (c == 'B');
e.push_back(make_pair(make_pair(u, v), b));
}
go(0);
go(1);
if (ans == 1000000000)
cout << -1 << endl;
else {
cout << ans << endl;
for (int i = 0; i < (vs.size()); i++) {
cout << vs[i] + 1 << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const long long md = 1e9 + 7;
const int inf = 1e9;
vector<pair<int, int> > G[maxn];
bool vis[maxn];
int val[maxn];
bool inval;
bool st[maxn][3];
pair<int, int> dfs(int x, int v, int m) {
val[x] = v;
vis[x] = true;
pair<int, int> ans = make_pair(val[x] == 1, 1);
for (pair<int, int> p : G[x]) {
int y = p.first, z = p.second;
if (vis[y]) {
if (val[y] != val[x] ^ z ^ m) {
inval = true;
return ans;
}
} else {
pair<int, int> cur = dfs(y, val[x] ^ z ^ m, m);
ans.first += cur.first;
ans.second += cur.second;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = (1); i <= (m); i++) {
int x, y;
char c;
cin >> x >> y >> c;
c = (c == 'R');
G[x].emplace_back(make_pair(y, c));
G[y].emplace_back(make_pair(x, c));
}
int ans = inf;
int typ = -1;
for (int mode = (0); mode <= (1); mode++) {
inval = false;
for (int i = (1); i <= (n); i++) {
st[i][mode] = 0;
vis[i] = false;
val[i] = -1;
}
int cur = 0;
for (int i = (1); i <= (n); i++) {
if (!vis[i]) {
pair<int, int> p = dfs(i, 0, mode);
if (inval) {
cur = inf;
break;
}
cur += min(p.first, p.second - p.first);
if (p.first < p.second - p.first) {
st[i][mode] = 0;
} else {
st[i][mode] = 1;
}
}
}
if (cur < ans) {
typ = mode;
ans = cur;
}
}
if (ans >= inf) {
cout << -1 << endl;
return 0;
}
for (int i = (1); i <= (n); i++) {
vis[i] = false;
val[i] = -1;
}
for (int i = (1); i <= (n); i++) {
if (!vis[i]) {
pair<int, int> p = dfs(i, st[i][typ], typ);
}
}
cout << ans << endl;
for (int i = (1); i <= (n); i++) {
if (val[i]) {
cout << i << " ";
}
}
cout << endl;
}
|
#include <bits/stdc++.h>
struct EDGE {
int u, v, c;
} e[1000010];
struct edge {
int b, ne;
} da[2 * 1000010];
int head[1000010], TOT, fa[1000010];
void insert(int a, int b) {
da[++TOT].b = b;
da[TOT].ne = head[a];
head[a] = TOT;
}
int anc(int x) { return fa[x] == x ? x : fa[x] = anc(fa[x]); }
int col[1000010], q[1000010];
std::vector<int> v[1000010], S[2], Ans[2];
void bfs(int Y) {
int op = 0, cl = 1;
q[1] = Y;
while (op < cl) {
int x = q[++op];
for (int i = 0; i < v[x].size(); i++) Ans[col[x]].push_back(v[x][i]);
for (int t = head[x]; t; t = da[t].ne)
if (col[da[t].b] == -1) col[da[t].b] = 1 - col[x], q[++cl] = da[t].b;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i].u, &e[i].v);
char s[2];
scanf("%s", s);
e[i].c = s[0] == 'R' ? 0 : 1;
}
for (int COLOR = 0; COLOR < 2; COLOR++) {
for (int i = 1; i <= n * 2; i++) fa[i] = i, v[i].clear(), fa[i + n] = i + n;
for (int i = 1; i <= m; i++)
if (COLOR == e[i].c)
fa[anc(e[i].u)] = anc(e[i].v), fa[anc(e[i].u + n)] = anc(e[i].v + n);
else {
fa[anc(e[i].u)] = anc(e[i].v + n);
fa[anc(e[i].u + n)] = anc(e[i].v);
}
bool g = true;
for (int i = 1; i <= n; i++)
if (anc(i) == anc(i + n)) {
g = false;
break;
}
if (!g) {
S[COLOR].resize(n + 1);
continue;
}
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++)
if (COLOR == e[i].c) fa[anc(e[i].u)] = anc(e[i].v);
for (int i = 1; i <= n; i++) v[anc(i)].push_back(i);
TOT = 0;
memset(head, 0, sizeof head);
for (int i = 1; i <= m; i++)
if (COLOR != e[i].c)
insert(anc(e[i].u), anc(e[i].v)), insert(anc(e[i].v), anc(e[i].u));
memset(col, -1, sizeof col);
for (int i = 1; i <= n; i++)
if (fa[i] == i && col[i] == -1) {
Ans[0].clear(), Ans[1].clear(), col[i] = 0, bfs(i);
if (Ans[0].size() < Ans[1].size())
for (int j = 0; j < Ans[0].size(); j++) S[COLOR].push_back(Ans[0][j]);
else
for (int j = 0; j < Ans[1].size(); j++) S[COLOR].push_back(Ans[1][j]);
}
}
if (S[0].size() == n + 1 && S[1].size() == n + 1)
printf("-1");
else if (S[0].size() < S[1].size()) {
printf("%d\n", S[0].size());
for (int i = 0; i < S[0].size(); i++) printf("%d ", S[0][i]);
} else {
printf("%d\n", S[1].size());
for (int i = 0; i < S[1].size(); i++) printf("%d ", S[1][i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
vector<pair<int, int> > V[200005];
int n, m;
vector<int> RR[2], res;
int color[200005];
int que[200005], size;
bool cal(int id) {
memset(color, -1, sizeof(color));
RR[id].clear();
for (int i = (1); i <= (n); ++i)
if (color[i] == -1) {
size = 0;
que[size++] = i;
int mau = 0;
color[i] = 1;
for (int t = 0; t < (size); ++t) {
int u = que[t];
mau += color[u];
for (int j = 0; j < (((int)(V[u]).size())); ++j) {
int v = V[u][j].first;
int c = V[u][j].second;
if (color[v] != -1) {
if (color[u] ^ color[v] ^ id ^ c) {
return 0;
}
} else {
color[v] = color[u] ^ id ^ c;
que[size++] = v;
}
}
}
for (int t = 0; t < (size); ++t) {
int u = que[t];
if (mau > size / 2) {
if (!color[u]) RR[id].push_back(u);
} else {
if (color[u]) RR[id].push_back(u);
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int run = 0; run < (m); ++run) {
int u, v;
char ch;
cin >> u >> v >> ch;
int id = (ch == 'R' ? 1 : 0);
V[u].push_back(make_pair(v, id));
V[v].push_back(make_pair(u, id));
}
if (cal(0)) {
if (cal(1)) {
if (((int)(RR[0]).size()) < ((int)(RR[1]).size())) {
res = RR[0];
} else
res = RR[1];
} else
res = RR[0];
} else {
if (cal(1))
res = RR[1];
else {
cout << -1 << endl;
return 0;
}
}
cout << ((int)(res).size()) << endl;
for (int i = 0; i < (((int)(res).size())); ++i) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, m;
vector<pair<int, char> > edges[MAXN];
int val[MAXN];
int vis[MAXN];
char letter;
vector<int> comp;
int mini = 1e9, oa, answer = 0, answer2 = 0;
char lea;
void solve(int node, int on) {
val[node] = on;
vis[node] = 1;
for (pair<int, char>& t : edges[node]) {
if (vis[t.first]) continue;
if (on == (t.second != letter))
solve(t.first, 0);
else
solve(t.first, 1);
}
}
void get(int on, char let) {
letter = let;
for (int y : comp) val[y] = vis[y] = 0;
solve(comp[0], on);
int ans = 0;
for (int g : comp) ans += val[g];
bool flag = 1;
for (int g : comp) {
for (pair<int, char>& y : edges[g]) {
if ((val[g] ^ val[y.first]) != (y.second != let)) flag = 0;
}
}
if (!flag) return;
if (ans < mini) mini = ans, oa = on, lea = let;
}
void dfs(int node) {
comp.push_back(node);
vis[node] = 1;
for (pair<int, char>& g : edges[node]) {
if (vis[g.first]) continue;
dfs(g.first);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int g = 0; g < m; g++) {
int a, b;
cin >> a >> b;
char c;
cin >> c;
edges[a].push_back(pair<int, char>(b, c));
edges[b].push_back(pair<int, char>(a, c));
}
vector<int> vo, vo2;
for (int g = 1; g <= n; g++) {
if (vis[g]) continue;
mini = 1e9;
comp.clear();
dfs(g);
get(0, 'B');
get(1, 'B');
if (mini == 1e9) {
answer = 1e9;
}
answer += mini;
letter = lea;
for (int y : comp) val[y] = vis[y] = 0;
solve(comp[0], oa);
for (int y : comp) {
if (val[y]) vo.push_back(y);
}
}
memset(vis, 0, sizeof(vis));
memset(val, 0, sizeof(val));
mini = 1e9, oa = 0;
for (int g = 1; g <= n; g++) {
if (vis[g]) continue;
mini = 1e9;
comp.clear();
dfs(g);
get(0, 'R');
get(1, 'R');
if (mini == 1e9) {
answer2 = 1e9;
}
answer2 += mini;
letter = lea;
for (int y : comp) val[y] = vis[y] = 0;
solve(comp[0], oa);
for (int y : comp) {
if (val[y]) vo2.push_back(y);
}
}
if (min(answer, answer2) >= 1e9) {
cout << -1;
return 0;
}
if (answer < answer2) {
cout << answer << '\n';
for (int t : vo) cout << t << ' ';
} else {
cout << answer2 << '\n';
for (int t : vo2) cout << t << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static int N, M;
static vector<vector<pair<bool, int>>> adj;
static vector<int> sides[2];
static vector<int> visited;
static vector<int> solution;
bool dfs(int i, int side) {
if (visited[i] != -1) {
return visited[i] == side;
}
visited[i] = side;
sides[side].push_back(i);
for (pair<bool, int> col_j : adj[i]) {
if (!dfs(col_j.second, side ^ col_j.first)) return false;
}
return true;
}
bool solve() {
solution.clear();
visited = vector<int>(N, -1);
for (int i = 0; i < N; ++i) {
if (visited[i] == -1) {
sides[0].clear();
sides[1].clear();
if (!dfs(i, 0)) return false;
if (sides[0].size() > sides[1].size()) sides[0].swap(sides[1]);
for (int i : sides[0]) {
solution.push_back(i);
}
}
}
return true;
}
void output(const vector<int>& sol) {
cout << sol.size() << '\n';
for (int i = 0; i < sol.size(); ++i) {
if (i > 0) cout << ' ';
cout << sol[i] + 1;
}
cout << '\n';
}
int main() {
cin >> N >> M;
adj.resize(N);
for (int m = int(0); m < int(M); ++m) {
int i, j;
string s;
cin >> i >> j >> s;
assert(s == "R" || s == "B");
bool col = (s == "R");
adj[i - 1].push_back({col, j - 1});
adj[j - 1].push_back({col, i - 1});
}
bool a = solve();
vector<int> sol1 = solution;
for (int i = int(0); i < int(N); ++i)
for (int j = int(0); j < int(adj[i].size()); ++j) adj[i][j].first ^= 1;
bool b = solve();
vector<int> sol2 = solution;
if (a && (!b || sol1.size() <= sol2.size())) {
output(sol1);
} else if (b) {
output(sol2);
} else {
cout << -1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<pair<int, int> > adj[100100];
int n, m;
pair<pair<int, int>, int> edge[100100];
int col[100100];
vector<int> vec[2];
bool dfs(int u, int c = 0) {
col[u] = c;
vec[c].push_back(u);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].first;
if (col[v] != -1) {
if (col[v] == col[u] && adj[u][i].second) return false;
if (col[v] != col[u] && !adj[u][i].second) return false;
continue;
}
if (!dfs(v, c ^ adj[u][i].second)) return false;
}
return true;
}
vector<int> ids;
int solve(int tp) {
for (int i = 1; i <= n; i++) adj[i].clear(), col[i] = -1;
for (int i = 0; i < m; i++) {
int u = edge[i].first.first;
int v = edge[i].first.second;
adj[u].push_back(pair<int, int>(v, edge[i].second == tp));
adj[v].push_back(pair<int, int>(u, edge[i].second == tp));
}
ids.clear();
for (int i = 1; i <= n; i++)
if (col[i] == -1) {
vec[0].clear();
vec[1].clear();
if (!dfs(i)) return 0x3f3f3f3f;
int tp = vec[0].size() > vec[1].size();
for (int j = 0; j < vec[tp].size(); j++) ids.push_back(vec[tp][j]);
}
return ids.size();
}
int main() {
gn(n, m);
for (int i = 0; i < m; i++) {
int u, v;
char c;
gn(u, v);
scanf(" %c", &c);
edge[i] = pair<pair<int, int>, int>(pair<int, int>(u, v), c == 'R');
}
int ans = solve(0);
vector<int> res = ids;
int tmp = solve(1);
if (tmp < ans) ans = tmp, res = ids;
if (ans < 0x3f3f3f3f) {
println(ans);
for (int i = 0; i < res.size(); i++) printsp(res[i]);
puts("");
} else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
vector<pair<int, int> > g[N];
vector<int> G[N];
int n, m;
int color[N], cols, anss[3];
vector<int> ansn, tmpans, tmpanss[3];
vector<int> component[N];
int ans, pra, sz[N], vis[N], black[N];
void dfs(int u, int f) {
color[u] = cols;
sz[cols]++;
component[cols].push_back(u);
vis[u] = 1;
for (pair<int, int> vv : g[u]) {
if (vv.second != pra) continue;
int v = vv.first;
if (vis[v] == 1) continue;
dfs(v, u);
}
}
int rebuild() {
for (int i = 1; i <= cols; ++i) G[i].clear();
for (int u = 1; u <= n; ++u) {
for (pair<int, int> vv : g[u]) {
if (vv.second == pra) continue;
int v = vv.first;
if (color[v] == color[u]) return 0;
G[color[u]].push_back(color[v]);
}
}
return 1;
}
int check(int u, int f, int flag) {
if (black[u] != 0) return black[u] == flag;
int res = 1;
black[u] = flag;
tmpanss[flag].push_back(u);
anss[flag] += sz[u];
for (int v : G[u]) {
res &= check(v, u, 3 - flag);
}
return res;
}
void solve(int para) {
pra = para;
cols = 0;
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; ++i) {
if (vis[i] == 0) {
cols++;
component[cols].clear();
sz[cols] = 0;
dfs(i, -1);
}
}
int ok = rebuild();
int res = 0;
memset(black, 0, sizeof black);
tmpans.clear();
for (int i = 1; i <= cols && ok; ++i) {
if (black[i] != 0) continue;
tmpanss[1].clear();
tmpanss[2].clear();
anss[1] = anss[2] = 0;
ok &= check(i, -1, 1);
int pos = 1;
if (anss[1] > anss[2]) pos = 2;
res += min(anss[1], anss[2]);
for (int v : tmpanss[pos]) {
for (int vv : component[v]) {
tmpans.push_back(vv);
}
}
}
if (ok == 0) return;
if (res < ans) {
ans = res;
ansn.clear();
for (int v : tmpans) ansn.push_back(v);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
char s[10];
int x, y;
scanf("%d %d %s", &x, &y, s);
int col = s[0] == 'R';
g[x].push_back(make_pair(y, col));
g[y].push_back(make_pair(x, col));
}
ans = n + 1;
solve(0);
solve(1);
if (ans == n + 1)
puts("-1");
else {
printf("%d\n", ans);
for (int i = 0; i < ansn.size(); ++i) printf("%d ", ansn[i]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct Edge {
int v, col, next;
} E[maxn << 1];
int head[maxn], tol;
int vis[maxn], top, n, m;
vector<int> g[2], st[2];
void init() {
memset(head, -1, sizeof head);
tol = 0;
}
void add_edge(int u, int v, int col) {
E[tol].v = v;
E[tol].col = col;
E[tol].next = head[u];
head[u] = tol++;
}
bool dfs(int u, int f, int col) {
vis[u] = f;
st[f].push_back(u);
for (int i = head[u]; ~i; i = E[i].next) {
int v = E[i].v;
if (vis[v] != -1) {
if ((vis[u] ^ vis[v]) != (col ^ E[i].col)) return false;
continue;
}
if (!dfs(v, col ^ E[i].col ^ vis[u], col)) return false;
}
return true;
}
int solve(int col) {
memset(vis, -1, sizeof vis);
for (int i = 1; i <= n; i++) {
if (vis[i] == -1) {
st[0].clear();
st[1].clear();
if (!dfs(i, 0, col)) {
return n + 1;
}
int tmp = st[0].size() < st[1].size() ? 0 : 1;
g[col].insert(g[col].end(), st[tmp].begin(), st[tmp].end());
}
}
return g[col].size();
}
int main() {
int u, v;
char col;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
scanf("%d %d %c", &u, &v, &col);
add_edge(u, v, col == 'R' ? 1 : 0);
add_edge(v, u, col == 'R' ? 1 : 0);
}
int sz0 = solve(0);
int sz1 = solve(1);
if (sz0 == n + 1 && sz1 == n + 1) {
puts("-1");
return 0;
}
int tmp = sz0 < sz1 ? 0 : 1;
printf("%d\n", g[tmp].size());
for (int i = 0; i < g[tmp].size(); i++) {
printf("%d ", g[tmp][i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool testing = false;
const int M = 100001;
vector<pair<int, char>> v[M];
int g[M];
int fun(char c, vector<int>& res, int n) {
memset(g, 0, sizeof(g));
vector<int> x;
for (int d = 1; d < n + 1; d++) {
if (!g[d]) {
x.clear();
x.push_back(d);
g[d] = 1;
stack<int> s;
s.push(d);
while (s.size()) {
int p = s.top();
s.pop();
for (auto i : v[p]) {
if (i.second == c) {
if (g[i.first]) {
if (g[i.first] != g[p]) return M;
} else {
g[i.first] = g[p];
x.push_back(i.first);
s.push(i.first);
}
} else {
if (g[i.first]) {
if (g[i.first] == g[p]) return M;
} else {
g[i.first] = -g[p];
x.push_back(i.first);
s.push(i.first);
}
}
}
}
int sum = 0;
for (int pos : x) {
sum += g[pos];
}
if (sum > 0)
sum = -1;
else
sum = 1;
for (int pos : x) {
if (g[pos] == sum) res.push_back(pos);
}
}
}
return res.size();
}
void program() {
int n, m;
cin >> n >> m;
int a, b;
char c;
for (int i = 0; i < n + 1; i++) {
v[i].clear();
}
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
vector<int> res1, res2;
int r1 = fun('B', res1, n);
int r2 = fun('R', res2, n);
if (r2 < r1) {
r1 = r2;
res1 = res2;
}
if (r1 == M) r1 = -1;
cout << r1 << endl;
for (auto i : res1) {
cout << i << " ";
}
}
int main() {
if (!testing) {
program();
return 0;
}
FILE* fin = NULL;
fin = fopen("in.txt", "w+");
fprintf(fin, "3 3\n1 2 B\n3 1 R\n3 2 B\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(1) => expected : \n");
printf("1\n2 \n");
printf("test case(1) => founded : \n");
program();
fin = fopen("in.txt", "w+");
fprintf(fin, "6 5\n1 3 R\n2 3 R\n3 4 B\n4 5 R\n4 6 R\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(2) => expected : \n");
printf("2\n3 4 \n");
printf("test case(2) => founded : \n");
program();
fin = fopen("in.txt", "w+");
fprintf(fin, "4 5\n1 2 R\n1 3 R\n2 3 B\n3 4 B\n1 4 B\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(3) => expected : \n");
printf("-1\n");
printf("test case(3) => founded : \n");
program();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct type_edge {
int u, v;
bool c;
type_edge() {}
type_edge(int a, int b, bool d) {
u = a;
v = b;
c = d;
}
} edge[100005];
vector<int> G[200005];
int vis[200005], cnt, n;
int comp[200005], used[200005];
int dfs(int v, int mark) {
vis[v] = mark;
int ret = 0;
for (int x : G[v])
if (!vis[x]) ret += dfs(x, mark);
return ret + (v <= n ? 1 : 0);
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
char c;
scanf("%d%d %c", &a, &b, &c);
edge[i] = type_edge(a, b, (c == 'B'));
}
vector<int> ans;
bool has_ans = 0;
for (int color = 1; color >= 0; color--) {
for (int i = 1; i <= 2 * n; i++) {
G[i].clear();
vis[i] = 0;
comp[i] = 0;
used[i] = 0;
}
for (int i = 0; i < m; i++) {
int f = edge[i].u, s = edge[i].v;
if (edge[i].c == color) {
G[f].push_back(s);
G[s].push_back(f);
G[s + n].push_back(f + n);
G[f + n].push_back(s + n);
} else {
G[f].push_back(s + n);
G[s + n].push_back(f);
G[s].push_back(f + n);
G[f + n].push_back(s);
}
}
cnt = 1;
bool fail = 0;
for (int i = 1; i <= 2 * n; i++) {
if (!vis[i]) {
comp[cnt] = dfs(i, cnt);
cnt++;
}
}
set<int> comp_used;
for (int i = 1; i <= n; i++) {
if (vis[i] == vis[i + n]) {
fail = 1;
break;
}
if (used[vis[i]] || used[vis[i + n]]) {
assert(used[vis[i]] & used[vis[i + n]]);
continue;
}
used[vis[i]] = used[vis[i + n]] = 1;
if (comp[vis[i]] < comp[vis[i + n]])
comp_used.insert(vis[i]);
else
comp_used.insert(vis[i + n]);
}
if (fail) continue;
vector<int> aux;
for (int i = 1; i <= n; i++) {
if (comp_used.find(vis[i]) != comp_used.end()) aux.push_back(i);
}
if (color == 1)
ans = aux;
else if (aux.size() < ans.size() || !has_ans)
ans = aux;
has_ans = 1;
}
if (has_ans == 0)
printf("-1\n");
else {
printf("%d\n", ans.size());
for (int x : ans) printf("%d ", x);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 7;
vector<pair<int, int> > adj[MAX];
bool flag, visited[MAX], done;
int Color[MAX], one, zero, n, m;
vector<int> Ans, temp;
void dfs(int i, int color, int c = 0) {
temp.push_back(i);
Color[i] = c;
one += (c == 1);
zero += (c == 0);
visited[i] = true;
for (auto j : adj[i]) {
int u = j.second;
int edge_color = j.first;
if (!visited[u]) {
if (edge_color == color)
dfs(u, color, c);
else
dfs(u, color, !c);
} else {
if (edge_color == color && Color[i] != Color[u])
flag = false;
else if (edge_color != color && Color[i] == Color[u])
flag = false;
}
}
}
void func(int color) {
vector<int> ans;
flag = true;
fill(visited, visited + n + 2, false);
fill(Color, Color + n + 2, -1);
for (int i = 1; i <= n; i++)
if (!visited[i]) {
one = 0, zero = 0;
temp.clear();
dfs(i, color);
if (!flag) return;
int val = min(one, zero);
for (auto j : temp)
if (Color[j] == (val == one ? 1 : 0)) ans.push_back(j);
}
if (color == 0)
Ans = ans;
else if (!done)
Ans = ans;
else if (Ans.size() > ans.size())
Ans = ans;
done = true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
string s;
cin >> u >> v >> s;
adj[u].push_back(make_pair(s == "B", v));
adj[v].push_back(make_pair(s == "B", u));
}
func(0);
func(1);
if (!done)
cout << -1 << endl;
else {
cout << Ans.size() << endl;
for (auto j : Ans) cout << j << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, char> > grp[112345];
bool mark[112345];
vector<int> ans[2], p[3];
map<int, int> vp;
int n, e;
bool dfs(int part, char cl, int vx) {
p[part].push_back(vx);
mark[vx] = true;
vp[vx] = part;
for (int i = 0; i < grp[vx].size(); i++) {
int v = grp[vx][i].first;
char c = grp[vx][i].second;
int x;
if (c == cl)
x = part;
else
x = part % 2 + 1;
if (mark[v]) {
if (vp[v] != x) return false;
} else {
if (!dfs(x, cl, v)) return false;
}
}
return true;
}
bool solve(char clr, int as) {
for (int i = 0; i <= n; i++) {
mark[i] = false;
}
vp.clear();
for (int i = 1; i <= n; i++) {
p[0].clear();
p[1].clear();
p[2].clear();
if (mark[i] == false) {
if (dfs(1, clr, i) == true) {
if (p[1].size() < p[2].size()) {
for (int j = 0; j < p[1].size(); j++) ans[as].push_back(p[1][j]);
} else {
for (int j = 0; j < p[2].size(); j++) ans[as].push_back(p[2][j]);
}
} else {
return false;
}
}
}
return true;
}
int main() {
scanf("%d%d", &n, &e);
for (int i = 0; i < e; i++) {
int x, y;
char ch;
cin >> x >> y >> ch;
grp[x].push_back(make_pair(y, ch));
grp[y].push_back(make_pair(x, ch));
}
bool sr = solve('R', 1), sb = solve('B', 0);
int x = 1;
if (!sr && !sb) {
cout << -1 << endl;
return 0;
} else if (sr && sb) {
if (ans[0].size() < ans[1].size()) x = 0;
} else if (sr) {
x = 1;
} else
x = 0;
cout << ans[x].size() << endl;
;
for (int i = 0; i < ans[x].size(); i++) cout << ans[x][i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100010;
int N, M;
int cur_kind[maxN];
vector<int> kind_list[3];
vector<pair<int, int> > G[maxN];
void input() {
cin >> N >> M;
int u, v;
char c;
for (int i = 1; i <= M; i++) {
cin >> u >> v >> c;
G[u].push_back({v, c});
G[v].push_back({u, c});
}
}
bool getColoring(int node, int kind, char ch) {
if (cur_kind[node] != 0) return cur_kind[node] == kind;
cur_kind[node] = kind;
kind_list[kind].push_back(node);
bool ret = true;
int nxt_kind;
for (auto edge : G[node]) {
if (edge.second == ch)
nxt_kind = kind;
else {
if (kind == 1)
nxt_kind = 2;
else
nxt_kind = 1;
}
ret &= getColoring(edge.first, nxt_kind, ch);
}
return ret;
}
bool solve(char ch, vector<int> &store) {
for (int i = 1; i <= N; i++) cur_kind[i] = 0;
for (int i = 1; i <= N; i++) {
if (cur_kind[i] != 0) continue;
kind_list[1].clear();
kind_list[2].clear();
if (!getColoring(i, 1, ch)) return false;
if (kind_list[1].size() < kind_list[2].size()) {
for (auto node : kind_list[1]) store.push_back(node);
} else {
for (auto node : kind_list[2]) store.push_back(node);
}
}
return true;
}
void solve() {
vector<int> v, vb, vr;
bool ans = solve('R', vr);
if (ans) v = vr;
if (solve('B', vb)) {
if (ans) {
if (vb.size() < vr.size()) v = vb;
} else
v = vb;
ans = true;
}
if (!ans)
cout << "-1";
else {
cout << (int)v.size() << "\n";
for (auto node : v) cout << node << " ";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
inline int min(const int &first, const int &second) {
return (((second - first) >> (32 - 1)) & (first ^ second)) ^ first;
}
inline int max(const int &first, const int &second) {
return (((second - first) >> (32 - 1)) & (first ^ second)) ^ second;
}
inline long long min(const long long &first, const long long &second) {
return (((second - first) >> (64 - 1)) & (first ^ second)) ^ first;
}
inline long long max(const long long &first, const long long &second) {
return (((second - first) >> (64 - 1)) & (first ^ second)) ^ second;
}
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const unsigned int &first) { printf("%u", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T elem, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(elem);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace escape__from__random__aetuhoetnuhshe {
using namespace std::chrono;
mt19937 rng(duration_cast<milliseconds>(system_clock::now().time_since_epoch())
.count());
uniform_real_distribution<> prob_dist(0.0, 1.0);
}; // namespace escape__from__random__aetuhoetnuhshe
namespace typedefs {}
namespace numbers_operation {
template <class T>
inline T floor_mod(T a, const T &b) {
a %= b;
if (a < 0) a += b;
return a;
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
using namespace escape__from__random__aetuhoetnuhshe;
int n, m;
vector<vector<pair<int, int>>> g;
vector<bool> used;
vector<int> st;
vector<int> type;
bool dfs(int v, int cur, int req) {
st.push_back(v);
used[v] = true;
type[v] = cur;
for (pair<int, int> sub : g[v]) {
if (used[sub.first]) {
if ((type[sub.first] ^ type[v] ^ sub.second) != req) {
return false;
}
} else {
if (!dfs(sub.first, type[v] ^ sub.second ^ req, req)) return false;
}
}
return true;
}
signed main(signed argc, char *argv[]) {
cin, n, m;
g.resize(n);
type.resize(n);
for (int i = 0; i < (m); i++) {
int a, b;
string c;
cin, a, b;
cin, c;
a--;
b--;
g[a].emplace_back(b, c == "R");
g[b].emplace_back(a, c == "R");
}
vector<int> final(n + 1, -1);
for (int req = 0; req < 2; req++) {
vector<int> full;
used = vector<bool>(n, false);
for (int i = 0; i < (n); i++) {
if (used[i]) continue;
vector<int> best{-1};
for (int d = 0; d < (2); d++) {
st.clear();
if (dfs(i, d, req)) {
vector<int> acts;
for (int first : st) {
if (type[first]) acts.push_back(first);
}
if (best == vector<int>{-1} ||
((int)best.size()) > ((int)acts.size())) {
best = acts;
}
}
if (d == 0)
for (int first : st) {
used[first] = false;
}
}
if (best == vector<int>{-1}) best = vector<int>(n + 1, -1);
full.insert(full.end(), best.begin(), best.end());
if (((int)full.size()) > n) break;
}
if (((int) final.size()) > ((int)full.size())) final = full;
}
if (((int) final.size()) <= n) {
smart_io::precall_print();
cout, ((int) final.size());
for (auto &first : final) {
first++;
};
smart_io::precall_print();
cout, final;
} else {
smart_io::precall_print();
cout, -1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238463;
const long long mod = 1000000007;
const long long mod2 = 10000019;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U> &l, const std::pair<T, U> &r) {
return {l.first + r.first, l.second + r.second};
}
struct E {
int x;
int y;
int z;
};
bool cmpf(E &a1, E &a2) {
if (a1.x != a2.x) return a1.x < a2.x;
if (a1.y != a2.y) return a1.y < a2.y;
return a1.z < a2.z;
}
long long gcd(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return gcd(b, a % b);
}
const int nn = 100001;
vector<int> ad[nn], rr[nn], bb[nn];
int cnt, mp[nn], cl[nn];
vector<int> tt[nn], x1, x2, res;
int n, m;
void dfs(int a) {
mp[a] = cnt;
tt[cnt].push_back(a);
for (auto b : rr[a])
if (!mp[b]) dfs(b);
}
bool clr(int a, int x) {
cl[a] = x;
if (x == 1)
x1.push_back(a);
else
x2.push_back(a);
bool ret = 1;
for (auto b : ad[a]) {
if (cl[b] == cl[a]) return 0;
if (!cl[b]) ret = ret && clr(b, 3 - x);
}
return ret;
}
int cal() {
for (int i = (1); i <= (n); ++i)
if (!mp[i]) ++cnt, dfs(i);
for (int i = (1); i <= (n); ++i)
for (auto j : bb[i]) {
if (mp[i] == mp[j]) return -1;
ad[mp[i]].push_back(mp[j]);
ad[mp[j]].push_back(mp[i]);
}
for (int i = (1); i <= (cnt); ++i)
if (!cl[i]) {
x1.clear();
x2.clear();
if (!clr(i, 1)) return -1;
int a1 = 0, a2 = 0;
for (auto a : x1) a1 += tt[a].size();
for (auto a : x2) a2 += tt[a].size();
if (a1 < a2) {
for (auto b : x1) res.insert(res.end(), tt[b].begin(), tt[b].end());
} else {
for (auto b : x2) res.insert(res.end(), tt[b].begin(), tt[b].end());
}
}
return res.size();
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); i++) {
int a, b;
char c;
scanf("%d %d %c", &a, &b, &c);
if (c == 'R') {
rr[a].push_back(b);
rr[b].push_back(a);
} else {
bb[a].push_back(b);
bb[b].push_back(a);
}
}
int ans1 = cal();
vector<int> res1 = res;
res.clear();
for (int i = (1); i <= (nn); ++i) ad[i].clear(), tt[i].clear();
memset(cl, 0, sizeof cl);
memset(mp, 0, sizeof mp);
cnt = 0;
for (int i = (1); i <= (nn); ++i) swap(rr[i], bb[i]);
int ans2 = cal();
vector<int> res2 = res;
if (ans1 == -1 || (ans2 != -1 && ans1 > ans2)) {
swap(ans1, ans2);
swap(res1, res2);
}
cout << ans1 << endl;
if (ans1 != -1) {
for (auto x : res1) cout << x << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n, d, ans, hahaha[maxn];
char s[maxn];
bool pd[maxn];
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= d; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= n; j++)
if (s[j] == '0') pd[i] = 1;
}
for (int i = 1; i <= d; i++) {
if (pd[i] && pd[i - 1])
hahaha[i] = hahaha[i - 1] + 1;
else if (pd[i] && !pd[i - 1])
hahaha[i] = 1;
else if (!pd[i])
hahaha[i] = 0;
}
for (int i = 1; i <= d; i++) ans = max(hahaha[i], ans);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j = 0, k = 0, n, d, c, e, f;
cin >> n >> d;
string s;
for (i = 0; i < d; i++) {
cin >> s;
e = 1;
for (c = 0; c < n; c++) {
if (s[c] == '0') {
e = 0;
break;
}
}
if (e == 0) {
k++;
}
if (e == 1) {
k = 0;
}
if (k > j) {
j = k;
}
}
cout << j << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool zero(string n) {
for (int i = 0; i < n.length(); i++) {
if (n[i] == '0') return 1;
}
return 0;
}
int main() {
long long l, p;
cin >> l >> p;
string ST[200];
for (int i = 1; i <= p; i++) {
cin >> ST[i];
}
long long M = -100000000;
long long Ans = 0;
for (int i = 1; i <= p; i++) {
if (zero(ST[i])) {
Ans++;
} else {
Ans = 0;
}
if (Ans > M) {
M = Ans;
}
}
cout << M << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int t = 0, ans = 0;
for (int i = 0; i < m; ++i) {
string s;
cin >> s;
bool ck = true;
for (int j = 0; j < n; ++j) {
if (s[j] == '0') {
ck = false;
break;
}
}
if (ck == false) ++t;
if (ck == true) {
ans = max(t, ans);
t = 0;
}
}
ans = max(t, ans);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k = 0, mx = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int used = 0;
string s;
cin >> s;
for (int j = 0; j < n; j++) {
if (s[j] == '0') {
k++;
break;
}
if (j == n - 1) {
k = 0;
}
}
mx = max(k, mx);
}
cout << mx;
}
|
#include <bits/stdc++.h>
using namespace std;
bool is_any_abs(string s) {
for (char i : s) {
if (i == '0') return true;
}
return false;
}
int main() {
int n, d;
cin >> n >> d;
string s;
int ans = 0, cur = 0;
while (d--) {
cin >> s;
if (is_any_abs(s))
cur++;
else {
ans = max(ans, cur);
cur = 0;
}
}
ans = max(ans, cur);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int main() {
int n, d, t = 0, ans = 0, flag = 0;
char ar[200][200];
cin >> n >> d;
for (int i = 0; i < d; i++) {
flag = 0;
for (int j = 0; j < n; j++) {
cin >> ar[i][j];
if (ar[i][j] == '0') {
flag = 1;
}
}
if (flag) {
t++;
ans = max(t, ans);
} else {
t = 0;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, k = 0, x = 0, sum = 0;
string s;
while ((scanf("%d%d", &n, &d)) != EOF) {
k = 0;
x = 0;
sum = 0;
while (d--) {
cin >> s;
sum = 0;
int l = s.size();
for (int j = 0; j < l; j++) {
sum += (s[j] - '0');
}
if (sum == n) {
x = max(x, k);
k = 0;
} else
k++;
}
x = max(x, k);
printf("%d\n", x);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, d, max = 0, k = 0;
string x, c;
cin >> n >> d;
for (int i = 0; i < n; i++) {
c += "1";
}
for (int i = 0; i < d; i++) {
cin >> x;
if (x.compare(c) != 0) k++;
if (max < k) max = k;
if (x.compare(c) == 0) k = 0;
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
const double EPS = 0.0000000001;
const long long mod1 = 998244353;
const long long mod2 = 1000000007;
const long long mod3 = 1000000009;
const long long mod4 = 998244353;
const long long inf = 10000000000000000;
using namespace std;
signed main() {
cin.tie(0);
cout.tie(0);
std::ios_base::sync_with_stdio(0);
long long n, a;
cin >> n >> a;
long long matrix[a][n];
for (long long i = 0; i < a; i++) {
for (long long z = 0; z < n; z++) {
char c;
cin >> c;
matrix[i][z] = (c - '0');
}
}
bool used[a];
for (long long i = 0; i < a; i++) {
bool p = 0;
for (long long z = 0; z < n; z++) {
if (!matrix[i][z]) p = 1;
}
used[i] = p;
}
long long c = 0;
long long x = 1;
long long maxi = -1;
for (long long i = 0; i < a; i++) {
if (used[i]) {
c++;
continue;
}
maxi = max(maxi, c);
c = 0;
}
maxi = max(maxi, c);
cout << maxi;
}
|
#include <bits/stdc++.h>
using namespace std;
int foe(int n, string a);
int main() {
int n, d, count = 0, max = 0;
cin >> n >> d;
string str;
register int i;
for (i = 0; i < d; i++) {
cin >> str;
if (foe(n, str))
count++;
else {
if (count > max) max = count;
count = 0;
}
}
if (count > max) max = count;
cout << max;
return 0;
}
int foe(int n, string a) {
register int i;
for (i = 0; i < n; i++)
if (a[i] == '0') return 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, d;
scanf("%d%d", &n, &d);
char opp[d][n];
for (int i = 0; i < d; i++) {
scanf("%s", opp[i]);
}
int counter = 0, maxi = 0;
for (int i = 0; i < d; i++) {
bool beaten = false;
for (int k = 0; k < n; k++) {
if (opp[i][k] == '0') {
beaten = true;
counter++;
break;
}
}
if (!beaten) {
counter = 0;
}
if (counter > maxi) {
maxi = counter;
}
}
printf("%d\n", maxi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool beats[105];
int main() {
int n, d, i, j;
char str[105][105];
scanf("%d%d", &n, &d);
for (i = 0; i < d; i++) {
scanf("%s", str[i]);
for (j = 0; j < n; j++) {
if (str[i][j] == '0') {
beats[i] = 1;
}
}
}
int maxi = 0, cnt = beats[0];
for (i = 1; i < d; i++) {
if (beats[i]) {
cnt++;
} else {
maxi = max(maxi, cnt);
cnt = 0;
}
}
maxi = max(maxi, cnt);
printf("%d\n", maxi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool D = 1;
void setup(bool output_to_file = false, string fname = "input") {
ios_base::sync_with_stdio(false);
if (fopen((string("input.in")).c_str(), "r")) fname = "input";
if (fopen((string("code.01.in")).c_str(), "r")) fname = "code.01";
if (fopen((fname + ".in").c_str(), "r")) {
freopen((fname + ".in").c_str(), "r", stdin);
if (output_to_file) freopen((fname + ".out").c_str(), "w", stdout);
}
}
int op, n;
int32_t main() {
setup();
cin >> op >> n;
string lose = "";
for (int i = 0; i < (op); i++) lose += "1";
int cons = 0, maxcons = 0;
for (int i = 0; i < (n); i++) {
string ops;
cin >> ops;
if (ops == lose) {
cons = 0;
} else {
++cons;
}
maxcons = max(maxcons, cons);
;
}
cout << maxcons << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char a[200];
int n, d, sum[200], i, j, r, m, b[200], max;
while (scanf("%d %d", &n, &d) == 2) {
r = 0;
max = 0;
for (i = 0; i < d; i++) {
sum[i] = 0;
scanf("%s", a);
for (j = 0; j < n; j++) {
if (a[j] == '0')
m = 0;
else
m = 1;
sum[i] = sum[i] + m;
}
if (sum[i] < n)
r++;
else
r = 0;
b[i] = r;
if (b[i] > max) max = b[i];
}
printf("%d\n", max);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d;
string s;
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> d;
int ans = 0, res = 0;
while (d--) {
cin >> s;
bool l = false;
for (int i = 0; i < s.size(); i++)
if (s[i] == '0') {
l = true;
break;
}
if (!l) {
if (ans < res) ans = res;
res = 0;
} else
res++;
}
if (res > ans) ans = res;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
int flag = 0, mx = 0;
for (int i = 0; i < m; i++) {
string str;
cin >> str;
sort(str.begin(), str.end());
if (str[0] == '0')
++flag;
else
flag = 0;
mx = max(mx, flag);
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, k1, ans, tec, MAXN[1111111], h[111111], l, r;
string s, q;
bool f, used[1111];
vector<int> v;
int main() {
cin >> m >> n;
for (int i = 1; i <= n; ++i) {
cin >> s;
r = l;
for (int j = 0; j < s.size(); ++j) {
if (s[j] == '0') {
l++;
break;
}
}
if (l > r) {
ans = max(ans, l);
} else
l = 0;
}
cout << ans;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.