text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct EdgeColoring {
vector<int> from, to, col;
vector<vector<int>> vis;
EdgeColoring(int MAXN, int MAXC) : vis(MAXN, vector<int>(MAXC, -1)) {}
void dfs(int x, int y, int c1, int c2, int id) {
int w = vis[y][c1];
vis[x][c1] = id, vis[y][c1] = id ^ 1, col[id / 2] = c1;
if (w != -1)
dfs(y, to[w], c2, c1, w);
else
vis[y][c2] = -1;
}
void addEdge(int x, int y) {
from.insert(from.end(), {x, y});
to.insert(to.end(), {y, x});
int c1 = 0, c2 = 0;
while (vis[x][c1] != -1) c1++;
while (vis[y][c2] != -1) c2++;
col.push_back(c1);
if (c1 == c2) {
vis[x][c1] = from.size() - 2;
vis[y][c2] = from.size() - 1;
} else {
dfs(x, y, c1, c2, from.size() - 2);
}
}
};
int main() {
int n, m, k, t, tot = 0;
scanf("%d%d%d%d", &n, &m, &k, &t);
vector<int> deg(n + m + k * 2 / t + 100), id(n + m + 1);
EdgeColoring ec(n + m + k * 2 / t + 100, 202);
for (int i = 1; i <= k; ++i) {
static int u, v;
scanf("%d%d", &u, &v);
v += n;
if (deg[id[u]] % t == 0) id[u] = ++tot;
if (deg[id[v]] % t == 0) id[v] = ++tot;
deg[id[u]]++, deg[id[v]]++;
ec.addEdge(id[u], id[v]);
}
int uneven = 0;
for (int i = 1; i <= tot; ++i) uneven += deg[i] % t != 0;
printf("%d\n", uneven);
for (auto g : ec.col) printf("%d ", g + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t, tot;
int sz[2][210];
int num1[10010], num2[10010];
int ans[5010], pos[2][210];
int c[10010][210];
int id[210][210];
int main() {
scanf("%d%d%d%d", &n, &m, &k, &t);
if (t == 1) {
printf("0\n");
for (int i = 1; i <= k; i++) printf("1%c", i == k ? '\n' : ' ');
return 0;
}
for (int i = 1; i <= n; i++) sz[0][i] = t;
for (int i = 1; i <= m; i++) sz[1][i] = t;
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
id[x][y] = i;
if (sz[0][x] == t) sz[0][x] = 0, pos[0][x] = ++tot, num1[tot] = x;
if (sz[1][y] == t) sz[1][y] = 0, pos[1][y] = ++tot, num2[tot] = y;
sz[0][x]++;
x = pos[0][x];
sz[1][y]++;
y = pos[1][y];
int dx = 0, dy = 0;
for (int j = 1; j <= t; j++)
if (!c[x][j]) {
dx = j;
break;
}
for (int j = 1; j <= t; j++)
if (!c[y][j]) {
dy = j;
break;
}
c[x][dx] = y;
c[y][dy] = x;
if (dx != dy)
for (int p = y; p; p = c[p][dy], swap(dx, dy)) swap(c[p][dx], c[p][dy]);
}
int anss = 0;
for (int i = 1; i <= n; i++) anss += sz[0][i] != t;
for (int i = 1; i <= m; i++) anss += sz[1][i] != t;
printf("%d\n", anss);
for (int i = 1; i <= tot; i++)
for (int j = 1; j <= t; j++) ans[id[num1[i]][num2[c[i][j]]]] = j;
for (int i = 1; i <= k; i++) printf("%d%c", ans[i], i == k ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 5, K = 200 + 5, Q = 5000 + 5;
int k, ans[N][N];
namespace BIPATITE {
const int N = ::N * ::N + 5;
int lk[2][N][K];
int get_mex(bool d, int x) {
int i = 1;
while (lk[d][x][i]) ++i;
return i;
}
void add_e(int x, int y, int c) {
lk[0][x][c] = y;
lk[1][y][c] = x;
ans[x / ::N][y / ::N] = c;
}
void modify(bool d, int x, int c0, int c1) {
if (!lk[d][x][c0]) return;
int y = lk[d][x][c0];
lk[d][x][c0] = 0;
lk[d ^ 1][y][c0] = 0;
modify(d ^ 1, y, c1, c0);
if (!d)
add_e(x, y, c1);
else
add_e(y, x, c1);
}
void add_e(int x, int y) {
int lx = get_mex(0, x), ly = get_mex(1, y);
if (!lk[1][y][lx]) {
add_e(x, y, lx);
return;
}
if (!lk[0][x][ly]) {
add_e(x, y, ly);
return;
}
modify(1, y, lx, ly);
add_e(x, y, lx);
}
}; // namespace BIPATITE
int du[2][N];
int inc(bool d, int x) { return x * N + (du[d][x]++) / k; }
int main() {
int n, m, q;
cin >> n >> m >> q >> k;
static pair<int, int> e[Q];
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
int x1 = inc(0, x), y1 = inc(1, y);
BIPATITE::add_e(x1, y1);
e[i] = {x, y};
}
int ans1 = 0;
for (int x = 1; x <= n; ++x) ans1 += du[0][x] % k > 0;
for (int x = 1; x <= m; ++x) ans1 += du[1][x] % k > 0;
printf("%d\n", ans1);
for (int i = 1; i <= q; ++i) printf("%d ", ans[e[i].first][e[i].second]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (signed)(~0u >> 1);
typedef class Edge {
public:
int ed, nx, r;
Edge() {}
Edge(int ed, int nx, int r) : ed(ed), nx(nx), r(r) {}
} Edge;
typedef class MapManager {
public:
int* h;
vector<Edge> E;
MapManager() {}
MapManager(int n) {
h = new int[(n + 1)];
memset(h, -1, sizeof(int) * (n + 1));
}
~MapManager() {
delete[] h;
E.clear();
}
void add_edge(int u, int v, int r) {
E.emplace_back(v, h[u], r);
h[u] = (signed)E.size() - 1;
}
void add_arc(int u, int v, int r) {
add_edge(u, v, r);
add_edge(v, u, 0);
}
Edge& operator[](int p) { return E[p]; }
} MapManager;
typedef class Network {
public:
int S, T;
MapManager g;
int *d, *h;
Network(int S, int T) : S(S), T(T), g(T) {
d = new int[(T + 1)];
h = new int[(T + 1)];
}
~Network() {
delete[] d;
delete[] h;
}
bool bfs() {
queue<int> Q;
memset(d, -1, sizeof(int) * (T + 1));
d[S] = 0;
Q.push(S);
while (!Q.empty()) {
int e = Q.front();
Q.pop();
for (int i = g.h[e], eu; ~i; i = g[i].nx) {
eu = g[i].ed;
if (!g[i].r || ~d[eu]) continue;
d[eu] = d[e] + 1;
Q.push(eu);
}
}
return d[T] != -1;
}
int dfs(int p, int mf) {
if (p == T || !mf) return mf;
int flow = 0, f;
for (int &i = h[p], j, e; ~i; (i != -1) && (i = g[i].nx)) {
e = g[i].ed, j = i;
if (g[i].r && d[e] == d[p] + 1 && (f = dfs(e, min(mf, g[i].r))) > 0) {
g[j].r -= f;
g[j ^ 1].r += f;
flow += f;
mf -= f;
if (!mf) break;
}
}
return flow;
}
int dinic() {
int rt = 0;
while (bfs()) {
for (int i = 0; i <= T; i++) h[i] = g.h[i];
rt += dfs(S, inf);
}
return rt;
}
void add_edge(int u, int v, int r) { g.add_arc(u, v, r); }
int cnt_edges() { return g.E.size(); }
} Network;
const int N = 205;
int n, m, t;
int id[N][N];
int deg[2][N];
bool G[N][N];
int ans[5000];
int idx[N][N];
void solve(int k) {
Network network(n + m + 2, n + m + 3);
int S = 0, T = n + m + 1, SS = n + m + 2, TT = n + m + 3;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (G[i][j]) {
id[i][j] = network.cnt_edges();
network.add_edge(i, j + n, 1);
}
}
}
for (int i = 1; i <= n; i++) {
network.add_edge(SS, i, deg[0][i] / k);
network.add_edge(S, TT, deg[0][i] / k);
if (deg[0][i] % k) {
network.add_edge(S, i, 1);
}
}
for (int i = 1; i <= m; i++) {
network.add_edge(SS, T, deg[1][i] / k);
network.add_edge(i + n, TT, deg[1][i] / k);
if (deg[1][i] % k) {
network.add_edge(i + n, T, 1);
}
}
network.add_edge(T, S, inf);
network.dinic();
MapManager& g = network.g;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (G[i][j] && !g[id[i][j]].r) {
ans[idx[i][j]] = k;
G[i][j] = false;
--deg[0][i];
--deg[1][j];
}
}
}
}
int main() {
int _;
scanf("%d%d%d%d", &n, &m, &_, &t);
for (int i = 1, u, v; i <= _; i++) {
scanf("%d%d", &u, &v);
G[u][v] = true;
idx[u][v] = i;
++deg[0][u];
++deg[1][v];
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += !!(deg[0][i] % t);
for (int i = 1; i <= m; i++) ans += !!(deg[1][i] % t);
while (t) solve(t--);
printf("%d\n", ans);
for (int i = 1; i <= _; i++) {
if (!::ans[i]) ::ans[i] = 1;
printf("%d ", ::ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ft, cp, ed, x, y, lo, hi, SS, TT, S, T, V, ret;
int v[500], l[500], d[500], g[500], ex[50000], ey[50000];
int lbl[500][500], qd[50000], qn[50000], qc[50000];
void bd(int x, int y, int c) {
qd[++ed] = y, qn[ed] = l[x], l[x] = ed, qc[ed] = c;
}
int ISAP(int x, int y) {
int mn = V - 1, F = 0, R = y, t;
if (x == T) return y;
for (int i = l[x]; i; i = qn[i]) {
if (qc[i] > 0) {
if (v[x] == v[qd[i]] + 1) {
t = ISAP(qd[i], min(qc[i], R));
qc[i] -= t;
qc[i ^ 1] += t;
R -= t;
F += t;
if (v[S] >= V) return F;
if (!R) break;
}
mn = min(mn, v[qd[i]]);
}
}
if (!F) {
g[v[x]]--;
if (!g[v[x]]) v[S] = V;
v[x] = mn + 1;
g[v[x]]++;
}
return F;
}
int MaxFlow() {
memset(v, 0, sizeof(v));
memset(g, 0, sizeof(g));
int ret = 0;
g[0] = V;
while (v[S] < V) ret += ISAP(S, 1 << 30);
return ret;
}
int main() {
scanf("%d%d%d%d", &n, &m, &ft, &cp);
memset(lbl, -1, sizeof(lbl));
for (int i = (0); i < (ft); i++) {
scanf("%d%d", &x, &y);
x--, y--;
ex[i] = x, ey[i] = y;
lbl[x][y] = -2;
d[x]++, d[y + n]++;
}
for (int i = (0); i < (n + m); i++) ret += !!(d[i] % cp);
SS = n + m;
TT = SS + 1;
S = TT + 1;
T = S + 1;
V = n + m + 4;
for (int i = (0); i < (cp); i++) {
memset(l, 0, sizeof(l));
ed = 1;
for (int j = (0); j < (n); j++)
for (int k = (0); k < (m); k++)
if (lbl[j][k] == -2) bd(j, k + n, 1), bd(k + n, j, 0);
for (int j = (0); j < (n); j++) {
lo = d[j] / (cp - i);
hi = (d[j] + cp - i - 1) / (cp - i);
bd(SS, j, hi - lo), bd(j, SS, 0);
bd(S, j, lo), bd(j, S, 0);
bd(SS, T, lo), bd(T, SS, 0);
}
for (int j = (n); j < (n + m); j++) {
lo = d[j] / (cp - i);
hi = (d[j] + cp - i - 1) / (cp - i);
bd(j, TT, hi - lo), bd(TT, j, 0);
bd(S, TT, lo), bd(TT, S, 0);
bd(j, T, lo), bd(T, j, 0);
}
bd(TT, SS, (1 << 28)), bd(SS, TT, 0);
MaxFlow();
for (int j = (0); j < (n); j++)
for (int k = (l[j]); k; k = qn[k])
if (qd[k] >= n && qd[k] < n + m && !qc[k]) {
d[j]--;
d[qd[k]]--;
lbl[j][qd[k] - n] = i;
}
}
printf("%d\n", ret);
for (int i = (0); i < (ft); i++) printf("%d ", lbl[ex[i]][ey[i]] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int Data, Weight, Cost, Next;
};
const int inf = 1000000000;
int G[402];
Edge E[20000];
void Add(int Number, int X, int Y, int W, int C) {
E[Number * 2] = (Edge){Y, W, C, G[X]};
G[X] = Number * 2;
E[Number * 2 + 1] = (Edge){X, 0, -C, G[Y]};
G[Y] = Number * 2 + 1;
}
bool SPFA(int S, int T, int N) {
static int Dist[402], Pre[402], Queue[402];
static bool Flag[402];
for (int i = 0; i < N; i++) Dist[i] = inf;
Dist[S] = 0;
memset(Flag, 0, sizeof(Flag));
int F = 0, R = 1;
Queue[0] = S;
while (F != R) {
int V = Queue[F++], P = G[V];
Flag[V] = false;
if (F == N) F = 0;
while (P != -1) {
int U = E[P].Data;
if (Dist[V] + E[P].Cost < Dist[U] && E[P].Weight) {
Dist[U] = Dist[V] + E[P].Cost;
Pre[U] = P;
if (!Flag[U]) Flag[Queue[R++] = U] = true;
if (R == N) R = 0;
}
P = E[P].Next;
}
}
if (Dist[T] == inf) return false;
int V = T;
while (V != S) {
E[Pre[V]].Weight--;
E[Pre[V] ^ 1].Weight++;
V = E[Pre[V] ^ 1].Data;
}
return true;
}
int main() {
int M, N, K, Total;
scanf("%d%d%d%d", &M, &N, &K, &Total);
static int X[5000], Y[5000], Dx[200], Dy[200];
for (int i = 0; i < K; i++) {
scanf("%d%d", &X[i], &Y[i]);
Dx[--X[i]]++;
Dy[--Y[i]]++;
}
int Ans = 0;
for (int i = 0; i < M; i++)
if (Dx[i] % Total) Ans++;
for (int i = 0; i < N; i++)
if (Dy[i] % Total) Ans++;
printf("%d\n", Ans);
static int Number[5000];
memset(Number, 0, sizeof(Number));
for (int Current = Total; Current; Current--) {
int S = M + N, T = M + N + 1, Count = K;
for (int i = 0; i < M + N + 2; i++) G[i] = -1;
for (int i = 0; i < K; i++)
if (!Number[i]) Add(i, X[i], M + Y[i], 1, 0);
for (int i = 0; i < M; i++) {
Add(Count++, S, i, Dx[i] / Current, 0);
if (Dx[i] % Current) Add(Count++, S, i, 1, 1);
}
for (int i = 0; i < N; i++) {
Add(Count++, M + i, T, Dy[i] / Current, 0);
if (Dy[i] % Current) Add(Count++, M + i, T, 1, 1);
}
while (SPFA(S, T, M + N + 2))
;
for (int i = 0; i < K; i++)
if (!Number[i] && !E[i * 2].Weight) {
Number[i] = Current;
Dx[X[i]]--;
Dy[Y[i]]--;
}
}
for (int i = 0; i < K; i++) {
printf("%d", Number[i]);
putchar((i == K - 1) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dat {
int x, rev, f, cap, cost;
dat(int x = 0, int rev = 0, int f = 0, int cap = 0, int cost = 0)
: x(x), rev(rev), f(f), cap(cap), cost(cost) {}
};
vector<dat> v[5100];
void add(int s, int t, int ca, int co) {
int n = v[s].size();
int m = v[t].size();
v[s].push_back(dat(t, m, 0, ca, co));
v[t].push_back(dat(s, n, 0, 0, -co));
}
priority_queue<pair<int, int> > q;
pair<int, int> pa[5100];
int pot[5100], vis[5100], A[5100 * 10], dist[5100], col[5100][5100], a[5100],
b[5100], deg[5100], deg1[5100], fl[5100];
int mx = 0;
int doit(int de) {
int mxx = 0;
for (int i = 0; i <= de; i++) pot[i] = 1e9;
pot[0] = 0;
int qt = 0;
A[qt++] = 0;
int nodes = de + 1;
for (int i = 0; i <= de; i++) vis[i] = 0;
for (int qh = 0; (qh - qt) % nodes != 0; qh++) {
int u = A[qh % nodes];
vis[u] = false;
for (int i = 0; i < (int)v[u].size(); i++) {
dat e = v[u][i];
if (e.cap == e.f) continue;
int vv = e.x;
int ndist = pot[u] + e.cost;
if (pot[vv] > ndist) {
pot[vv] = ndist;
if (!vis[vv]) {
vis[vv] = true;
A[qt++ % nodes] = vv;
}
}
}
}
while (1) {
for (int i = 0; i <= de; i++) fl[de] = 0;
for (int i = 0; i <= de; i++) dist[i] = 1e9;
dist[0] = 0;
while (!q.empty()) q.pop();
q.push(pair<int, int>(0, 0));
fl[0] = 1e9;
while (!q.empty()) {
pair<int, int> aa = q.top();
q.pop();
int x = aa.second;
if (-aa.first != dist[x]) continue;
for (int i = 0; i < v[x].size(); i++) {
dat bb = v[x][i];
if (bb.f == bb.cap) continue;
int y = bb.x;
int xx = dist[x] + bb.cost + pot[x] - pot[y];
if (dist[y] > xx) {
dist[y] = xx;
q.push(pair<int, int>(-dist[y], y));
pa[y] = pair<int, int>(x, i);
fl[y] = min(fl[x], bb.cap - bb.f);
}
}
}
if (!fl[de]) break;
mxx += fl[de];
for (int i = 0; i <= de; i++) pot[i] += dist[i];
int x = de;
while (1) {
pair<int, int> aa = pa[x];
int y = aa.first;
int id = aa.second;
v[y][id].f += fl[de];
v[x][v[y][id].rev].f -= fl[de];
if (!y) break;
x = y;
}
}
return mxx;
}
int main() {
int n, m, K, T;
scanf("%d%d%d%d", &n, &m, &K, &T);
for (int i = 1; i <= K; i++) {
scanf("%d%d", &a[i], &b[i]);
deg[a[i]]++;
deg1[b[i]]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += (deg[i] % T) > 0;
for (int i = 1; i <= m; i++) ans += (deg1[i] % T) > 0;
printf("%d\n", ans);
int so = 0;
int de = m + n + 1;
mx = 0;
for (int i = T; i; i--) {
for (int j = 0; j <= de; j++) v[j].clear();
for (int j = 1; j <= K; j++)
if (!col[a[j]][b[j]]) {
add(a[j], b[j] + n, 1, 0);
}
int kt = 0;
for (int j = 1; j <= n; j++) {
add(so, j, deg[j] / i, 0);
kt += deg[j] / i;
if (deg[j] % i) add(so, j, 1, 1);
}
int kt1 = 0;
for (int j = 1; j <= m; j++) {
add(j + n, de, deg1[j] / i, 0);
if (deg1[j] % i) add(j + n, de, 1, 1);
}
int mm = doit(de);
mx += mm;
for (int j = 1; j <= n; j++) {
for (int k = 0; k < v[j].size(); k++) {
dat aa = v[j][k];
if (aa.x == so) continue;
if (aa.f == 1) {
int y = aa.x;
if (y > n && y <= n + m) {
col[j][y - n] = i;
deg[j]--, deg1[y - n]--;
}
}
}
}
}
for (int i = 1; i <= K; i++) printf("%d ", col[a[i]][b[i]]);
puts("");
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
struct edge {
int from, to, nxt, flow, id;
} e[50 * 10010];
int fir[10010], deg[10010], mark[10010], cur[10010], lev[10010];
int cur1[10010], cur2[10010];
int x[10010], y[10010], col[10010];
int n1, n2, m, k;
int cnt, tot, S, T;
void add_edge(int x, int y, int flow, int id) {
e[tot].from = x;
e[tot].to = y;
e[tot].flow = flow;
e[tot].id = id;
e[tot].nxt = fir[x];
fir[x] = tot++;
e[tot].from = y;
e[tot].to = x;
e[tot].flow = 0;
e[tot].id = id;
e[tot].nxt = fir[y];
fir[y] = tot++;
}
int dfs(int now, int limit) {
if (now == T) return limit;
int ret = 0;
for (int i = cur[now]; ~i; cur[now] = i = e[i].nxt)
if (e[i].flow && lev[e[i].to] == lev[now] + 1) {
int tmp = dfs(e[i].to, std::min(e[i].flow, limit));
ret += tmp;
limit -= tmp;
e[i].flow -= tmp;
e[i ^ 1].flow += tmp;
if (!limit) return ret;
}
return ret;
}
int dinic() {
static int q[10010];
int ret = 0;
while (1) {
for (int i = 0; i <= T; i++) lev[i] = 0, cur[i] = fir[i];
int h = 1, t = 1;
q[1] = S;
lev[S] = 1;
while (h <= t) {
int now = q[h++];
for (int i = fir[now]; ~i; i = e[i].nxt)
if (e[i].flow && !lev[e[i].to]) {
q[++t] = e[i].to;
lev[e[i].to] = lev[now] + 1;
}
}
if (!lev[T]) break;
ret += dfs(S, 0x3f3f3f3f);
}
return ret;
}
int main() {
n1 = read();
n2 = read();
m = read();
k = read();
for (int i = 1; i <= n1; i++) cur1[i] = i, mark[i] = -1;
for (int i = 1; i <= n2; i++) cur2[i] = i + n1, mark[i + n1] = 1;
cnt = n1 + n2;
memset(fir, 255, sizeof(fir));
tot = 0;
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if (deg[cur1[x]] == k) cur1[x] = ++cnt, mark[cur1[x]] = -1;
if (deg[cur2[y]] == k) cur2[y] = ++cnt, mark[cur2[y]] = 1;
add_edge(cur1[x], cur2[y], 1, i);
++deg[cur1[x]];
++deg[cur2[y]];
}
int ans = 0;
for (int i = 1; i <= cnt; i++) ans += (deg[i]) && (deg[i] < k);
writeln(ans);
int last = 1;
for (int i = 1; i <= cnt; i++)
if (mark[i] == -1) {
while (deg[i] < k) {
while (mark[last] != 1 || deg[last] == k) {
++last;
if (last > cnt) mark[last] = 1, ++cnt;
}
add_edge(i, last, 1, 0);
++deg[i];
++deg[last];
}
}
last = 1;
for (int i = 1; i <= cnt; i++)
if (mark[i] == 1) {
while (deg[i] < k) {
while (mark[last] != -1 || deg[last] == k) {
++last;
if (last > cnt) mark[last] = -1, ++cnt;
}
add_edge(last, i, 1, 0);
++deg[last];
++deg[i];
}
}
S = 0;
T = cnt + 1;
for (int i = 1; i <= cnt; i++)
if (mark[i] == -1)
add_edge(S, i, 1, 0);
else
add_edge(i, T, 1, 0);
for (int i = 1; i <= k; i++) {
for (int j = fir[S]; ~j; j = e[j].nxt) e[j].flow = 1, e[j ^ 1].flow = 0;
for (int j = fir[T]; ~j; j = e[j].nxt) e[j].flow = 0, e[j ^ 1].flow = 1;
dinic();
for (int j = 0; j < tot; j++)
if (mark[e[j].from] == -1 && mark[e[j].to] == 1 && e[j ^ 1].flow) {
col[e[j].id] = i;
e[j ^ 1].flow = 0;
}
}
for (int i = 1; i <= m; i++) writesp(col[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
const int N = 6000 + 19;
const int M = 6000 + 19;
struct edge {
int x, y;
} e[M], E[M];
int pa[N][200 + 19], pb[N][200 + 19];
int ta[N], tb[N], da[N], db[N], da2[N], db2[N], col[N];
int na, nb, m, k, ca, cb, ans, x, y;
map<pair<int, int>, int> A;
void dfs1(int, int, int);
void dfs2(int y, int ca, int cb) {
int x = pb[y][ca];
if (!x) {
return;
} else {
pa[x][ca] = 0;
pb[y][ca] = 0;
dfs1(x, ca, cb);
pa[x][cb] = y;
pb[y][cb] = x;
}
}
void dfs1(int x, int ca, int cb) {
int y = pa[x][cb];
if (!y) {
return;
} else {
pa[x][cb] = 0;
pb[y][cb] = 0;
dfs2(y, ca, cb);
pa[x][ca] = y;
pb[y][ca] = x;
}
}
int main() {
na = IN(), nb = IN(), m = IN(), k = IN();
for (int i = 0; i < m; i++) {
x = IN(), y = IN();
e[i] = (edge){x, y};
da[x]++;
db[y]++;
if (!ta[x] || da2[ta[x]] == k) ta[x] = ++ca;
if (!tb[y] || db2[tb[y]] == k) tb[y] = ++cb;
E[i] = (edge){ta[x], tb[y]};
A[make_pair(ta[x], tb[y])] = i;
da2[ta[x]]++;
db2[tb[y]]++;
fprintf(stderr, "%d %d\n", ta[x], tb[y]);
}
for (int i = 1; i < na + 1; i++)
if (da[i] % k != 0) ans++;
for (int i = 1; i < nb + 1; i++)
if (db[i] % k != 0) ans++;
for (int w = 0; w < m; w++) {
int ca = -1, cb = -1;
x = E[w].x, y = E[w].y;
for (int i = 0; i < k; i++)
if (!pa[x][i]) {
ca = i;
break;
}
for (int i = 0; i < k; i++)
if (!pb[y][i]) {
cb = i;
break;
}
assert(ca != -1 && cb != -1);
if (ca == cb) {
pa[x][ca] = y;
pb[y][cb] = x;
} else {
if (ca < cb) {
dfs2(y, ca, cb);
pa[x][ca] = y;
pb[y][ca] = x;
} else {
dfs1(x, ca, cb);
pa[x][cb] = y;
pb[y][cb] = x;
}
}
}
memset(col, -1, sizeof(col));
for (int i = 1; i < ca + 1; i++) {
for (int j = 0; j < k; j++)
if (pa[i][j]) {
col[A[make_pair(i, pa[i][j])]] = j;
}
}
printf("%d\n", ans);
for (int i = 0; i < m; i++) printf("%d ", col[i] + 1);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxM = 20005, maxN = 505;
const int maxQ = 500;
const int oo = 100000000;
struct Te {
int u, v;
} e[maxM];
struct Tedge {
int v, c, w, next;
} edge[maxM];
int dad[maxN], edges;
int n, m, k, s, t, tot, c[maxM];
int dis[maxN], que[maxN];
int degree[maxN];
int fa[maxN];
void insertedge(int u, int v, int c, int w) {
edges++;
edge[edges].v = v;
edge[edges].c = c;
edge[edges].w = w;
edge[edges].next = dad[u];
dad[u] = edges;
}
void Readln() {
scanf("%d%d%d%d\n", &n, &m, &k, &tot);
for (int i = 1; i <= k; i++) {
scanf("%d%d\n", &e[i].u, &e[i].v);
degree[e[i].u]++;
degree[n + e[i].v]++;
}
int ans = 0;
for (int i = 1; i <= n + m; i++)
if (degree[i] % tot != 0) ans++;
printf("%d\n", ans);
}
bool SPFA() {
for (int i = s; i <= t; i++) dis[i] = oo;
dis[s] = 0;
int head = 1, tail = 1;
que[1] = s;
while (head <= tail) {
int now = que[head % maxQ];
head++;
for (int i = dad[now]; i != 0; i = edge[i].next)
if (edge[i].c > 0 && dis[now] + edge[i].w < dis[edge[i].v]) {
fa[edge[i].v] = i;
dis[edge[i].v] = dis[now] + edge[i].w;
tail++;
que[tail % maxQ] = edge[i].v;
}
}
return dis[t] != oo;
}
void Solve() {
for (int i = tot; i; i--) {
s = 0;
t = n + m + 1;
edges = 0;
for (int j = s; j <= t; j++) dad[j] = 0;
for (int j = 1; j <= k; j++)
if (!c[j]) {
insertedge(e[j].u, e[j].v + n, 1, 0);
insertedge(e[j].v + n, e[j].u, 0, 0);
}
for (int j = 1; j <= n; j++) {
insertedge(s, j, degree[j] / i, 0);
insertedge(j, s, 0, 0);
if (degree[j] % i != 0) {
insertedge(s, j, 1, 1);
insertedge(j, s, 0, -1);
}
}
for (int j = 1; j <= m; j++) {
insertedge(n + j, t, degree[n + j] / i, 0);
insertedge(t, n + j, 0, 0);
if (degree[n + j] % i != 0) {
insertedge(n + j, t, 1, 1);
insertedge(t, n + j, 0, -1);
}
}
while (SPFA()) {
for (int L = t; L != s; L = edge[((fa[L] - 1) ^ 1) + 1].v) {
edge[fa[L]].c--;
edge[((fa[L] - 1) ^ 1) + 1].c++;
}
}
int now = 0;
for (int j = 1; j <= k; j++)
if (!c[j]) {
now += 2;
if (edge[now].c) {
c[j] = i;
degree[e[j].u]--;
degree[e[j].v + n]--;
}
}
}
for (int i = 1; i <= k; i++) printf("%d ", c[i]);
}
int main() {
Readln();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dat {
int x, rev, f, cap, cost;
dat(int x = 0, int rev = 0, int f = 0, int cap = 0, int cost = 0)
: x(x), rev(rev), f(f), cap(cap), cost(cost) {}
};
vector<dat> v[5100];
void add(int s, int t, int ca, int co) {
int n = v[s].size();
int m = v[t].size();
v[s].push_back(dat(t, m, 0, ca, co));
v[t].push_back(dat(s, n, 0, 0, -co));
}
priority_queue<pair<int, int> > q;
pair<int, int> pa[5100];
int pot[5100], vis[5100], A[5100 * 10], dist[5100], col[5100][5100], a[5100],
b[5100], deg[5100], deg1[5100], fl[5100];
int mx = 0;
int doit(int de) {
int mxx = 0;
for (int i = 0; i <= de; i++) pot[i] = 0;
pot[0] = 0;
while (1) {
for (int i = 0; i <= de; i++) fl[de] = 0;
for (int i = 0; i <= de; i++) dist[i] = 1e9;
dist[0] = 0;
while (!q.empty()) q.pop();
q.push(pair<int, int>(0, 0));
fl[0] = 1e9;
while (!q.empty()) {
pair<int, int> aa = q.top();
q.pop();
int x = aa.second;
if (-aa.first != dist[x]) continue;
for (int i = 0; i < v[x].size(); i++) {
dat bb = v[x][i];
if (bb.f == bb.cap) continue;
int y = bb.x;
int xx = dist[x] + bb.cost + pot[x] - pot[y];
if (dist[y] > xx) {
dist[y] = xx;
q.push(pair<int, int>(-dist[y], y));
pa[y] = pair<int, int>(x, i);
fl[y] = min(fl[x], bb.cap - bb.f);
}
}
}
if (!fl[de]) break;
mxx += fl[de];
for (int i = 0; i <= de; i++) pot[i] += dist[i];
int x = de;
while (1) {
pair<int, int> aa = pa[x];
int y = aa.first;
int id = aa.second;
v[y][id].f += fl[de];
v[x][v[y][id].rev].f -= fl[de];
if (!y) break;
x = y;
}
}
return mxx;
}
int main() {
int n, m, K, T;
scanf("%d%d%d%d", &n, &m, &K, &T);
for (int i = 1; i <= K; i++) {
scanf("%d%d", &a[i], &b[i]);
deg[a[i]]++;
deg1[b[i]]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += (deg[i] % T) > 0;
for (int i = 1; i <= m; i++) ans += (deg1[i] % T) > 0;
printf("%d\n", ans);
int so = 0;
int de = m + n + 1;
mx = 0;
for (int i = T; i; i--) {
for (int j = 0; j <= de; j++) v[j].clear();
for (int j = 1; j <= K; j++)
if (!col[a[j]][b[j]]) {
add(a[j], b[j] + n, 1, 0);
}
int kt = 0;
for (int j = 1; j <= n; j++) {
add(so, j, deg[j] / i, 0);
kt += deg[j] / i;
if (deg[j] % i) add(so, j, 1, 1);
}
int kt1 = 0;
for (int j = 1; j <= m; j++) {
add(j + n, de, deg1[j] / i, 0);
if (deg1[j] % i) add(j + n, de, 1, 1);
}
int mm = doit(de);
mx += mm;
for (int j = 1; j <= n; j++) {
for (int k = 0; k < v[j].size(); k++) {
dat aa = v[j][k];
if (aa.x == so) continue;
if (aa.f == 1) {
int y = aa.x;
if (y > n && y <= n + m) {
col[j][y - n] = i;
deg[j]--, deg1[y - n]--;
}
}
}
}
}
for (int i = 1; i <= K; i++) printf("%d ", col[a[i]][b[i]]);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline void writeln(long long a) {
write(a);
puts("");
}
const int N = 4005;
int n1, n2, m, k, a[5005], b[5005], d[N], e[N];
int mat1[N * 2][N], mat2[N * 2][N], lx, ly;
void dfs(int p) {
if (!mat2[p][ly]) return;
int t = mat2[p][ly];
swap(mat1[t][lx], mat1[t][ly]);
if (!mat1[t][lx]) return;
swap(mat2[mat1[t][lx]][lx], mat2[mat1[t][lx]][ly]);
dfs(mat1[t][lx]);
}
map<int, int> M[N * 2];
signed main() {
n1 = read();
n2 = read();
m = read();
k = read();
for (int i = 1; i <= m; i++) {
a[i] = read();
b[i] = read();
d[a[i]]++;
e[b[i]]++;
}
int ans = 0;
for (int i = 1; i <= n1; i++) ans += d[i] % k != 0;
for (int i = 1; i <= n2; i++) ans += e[i] % k != 0;
int jb = n1;
for (int i = 1; i <= n1; i++) {
int dq = i, cnt = 0;
for (int j = 1; j <= m; j++)
if (a[j] == i) {
a[j] = dq;
cnt++;
if (cnt % k == 0) dq = ++jb;
}
}
n1 = jb;
jb = n2;
for (int i = 1; i <= n2; i++) {
int dq = i, cnt = 0;
for (int j = 1; j <= m; j++)
if (b[j] == i) {
b[j] = dq;
cnt++;
if (cnt % k == 0) dq = ++jb;
}
}
n2 = jb;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= k; j++)
if (!mat1[a[i]][j]) {
lx = j;
break;
}
for (int j = 1; j <= k; j++)
if (!mat2[b[i]][j]) {
ly = j;
break;
}
if (lx == ly) {
mat1[a[i]][lx] = b[i];
mat2[b[i]][ly] = a[i];
continue;
}
mat1[a[i]][lx] = b[i];
mat2[b[i]][ly] = mat2[b[i]][lx];
mat2[b[i]][lx] = a[i];
dfs(b[i]);
}
for (int i = 1; i <= n1; i++) {
for (int j = 1; j <= k; j++) {
M[i][mat1[i][j]] = j;
}
}
cout << ans << endl;
for (int i = 1; i <= m; i++) wri(M[a[i]][b[i]]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 410, K = 5e3 + 10;
struct Edge {
int u, v;
long long cap, flow;
int id;
Edge() {}
Edge(int u, int v, long long cap, int id)
: u(u), v(v), cap(cap), flow(0), id(id) {}
};
struct Dinic {
int N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void AddEdge(int u, int v, long long cap, int id) {
if (u != v) {
E.emplace_back(Edge(u, v, cap, id));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0, -1));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
int deg[N], lo[N], hi[N];
int u[K], v[K], type[K];
bool used[K];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, t;
cin >> n >> m >> k >> t;
for (int i = 1; i <= k; ++i) {
cin >> u[i] >> v[i];
v[i] += n;
++deg[u[i]];
++deg[v[i]];
}
int ans = 0;
for (int i = 1; i <= n + m; ++i) {
if (deg[i] % t) {
++ans;
}
}
for (int c = 1; c <= t; ++c) {
int source = 0, sink = n + m + 1;
int dummy_source = n + m + 2, dummy_sink = n + m + 3;
Dinic dinic(n + m + 4);
memset(deg, 0, sizeof(deg));
for (int i = 1; i <= k; ++i) {
if (!used[i]) {
dinic.AddEdge(u[i], v[i], 1, i);
++deg[u[i]];
++deg[v[i]];
}
}
int cur_t = (t - c + 1);
int sum_lhs = 0, sum_rhs = 0, inf = 0;
for (int i = 1; i <= n; ++i) {
lo[i] = deg[i] / cur_t;
hi[i] = (deg[i] + cur_t - 1) / cur_t;
dinic.AddEdge(dummy_source, i, hi[i] - lo[i], -1);
dinic.AddEdge(source, i, lo[i], -1);
sum_lhs += lo[i];
inf += hi[i];
}
for (int i = n + 1; i <= n + m; ++i) {
lo[i] = deg[i] / cur_t;
hi[i] = (deg[i] + cur_t - 1) / cur_t;
dinic.AddEdge(i, dummy_sink, hi[i] - lo[i], -1);
dinic.AddEdge(i, sink, lo[i], -1);
sum_rhs += lo[i];
}
dinic.AddEdge(source, dummy_sink, sum_rhs, -1);
dinic.AddEdge(dummy_sink, dummy_source, inf, -1);
dinic.AddEdge(dummy_source, sink, sum_lhs, -1);
assert(dinic.MaxFlow(source, sink) == sum_lhs + sum_rhs);
for (auto &e : dinic.E) {
if (e.id != -1 and e.flow) {
type[e.id] = c;
used[e.id] = true;
}
}
}
cout << ans << '\n';
for (int i = 1; i <= k; ++i) {
cout << type[i] << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405, M = (2e4 + 5) * 205, INF = 1e9, mk = 5005;
int n, m, K, t, h[N], e[M], pre[M], nxt[M], co[M], fl[M], tot, X[M], Y[M], calc,
vis[N], f[N], T, Ans[M], Id[N][N], now[N], dx[N], dy[N], ans;
void Add(int x, int y, int f, int c) {
e[++tot] = y;
nxt[tot] = h[x];
pre[h[x]] = tot;
fl[tot] = f;
co[tot] = c;
h[x] = tot;
}
bool aug(int x) {
vis[x] = calc;
if (x == T) return 1;
for (int i = now[x]; i; i = nxt[i])
if (fl[i] > 0 && vis[e[i]] < calc && f[x] == f[e[i]] + co[i]) {
if (aug(e[i])) {
fl[i]--;
fl[i ^ 1]++;
now[x] = i;
return 1;
}
}
return now[x] = 0;
}
void flow() {
for (int i = 0; i <= T; i++) now[i] = h[i];
for (;;) {
calc++;
if (!aug(0)) return;
}
}
bool check() {
int tmp = INF;
for (int i = 0; i <= T; i++)
if (vis[i] == calc) {
for (int j = h[i]; j; j = nxt[j])
if (fl[j] > 0 && vis[e[j]] < calc)
tmp = min(tmp, f[e[j]] + co[j] - f[i]);
}
if (tmp == INF) return 0;
for (int i = 0; i <= T; i++)
if (vis[i] == calc) f[i] += tmp;
return 1;
}
int main() {
scanf("%d%d%d%d", &n, &m, &K, &t);
for (int i = 1; i <= K; i++) {
scanf("%d%d", &X[i], &Y[i]);
Id[X[i]][Y[i]] = i;
dx[X[i]]++;
dy[Y[i]]++;
}
tot = 1;
memset(h, 0, sizeof(h));
T = n + m + 1;
for (int i = 1; i <= K; i++) {
Add(X[i], Y[i] + n, 1, 0);
Add(Y[i] + n, X[i], 0, 0);
}
for (int i = 1; i <= n; i++) ans += (dx[i] % t > 0);
for (int i = 1; i <= m; i++) ans += (dy[i] % t > 0);
printf("%d\n", ans);
for (int col = t; col; col--) {
memset(h, 0, sizeof(h));
tot = 1;
for (int i = 1; i <= K; i++)
if (!Ans[i]) {
Add(X[i], Y[i] + n, 1, 0);
Add(Y[i] + n, X[i], 0, 0);
}
for (int i = 1; i <= n; i++) {
Add(0, i, dx[i] / col, 0);
Add(i, 0, 0, 0);
if (dx[i] % col) {
Add(0, i, 1, 1);
Add(i, 0, 0, -1);
}
}
for (int i = 1; i <= m; i++) {
Add(i + n, T, dy[i] / col, 0);
Add(T, i + n, 0, 0);
if (dy[i] % col) {
Add(i + n, T, 1, 1);
Add(T, i + n, 0, -1);
}
}
memset(vis, 0, sizeof(vis));
calc = 0;
memset(f, 0, sizeof(f));
for (flow(); check(); flow())
;
for (int i = 1; i <= n; i++)
for (int j = h[i]; j; j = nxt[j])
if (e[j] > n && !fl[j]) {
dx[i]--;
dy[e[j] - n]--;
Ans[Id[i][e[j] - n]] = col;
}
}
for (int i = 1; i < K; i++) printf("%d ", Ans[i]);
printf("%d\n", Ans[K]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 705, M = 1e5 + 10, inf = 1e9;
int fr[M], to[M], nx[M], ls[N], vl[M], f[M], num = 0;
void link(int u, int v, int t, int w) {
to[++num] = v, fr[num] = u, nx[num] = ls[u], ls[u] = num;
vl[num] = w, f[num] = t;
to[++num] = u, fr[num] = v, nx[num] = ls[v], ls[v] = num;
vl[num] = -w, f[num] = 0;
}
struct node {
int u, v;
} e[M];
int S, T;
int d[N], col[M];
int dl[M], h[N], be[N];
bool vis[N];
bool bfs() {
int l = 0, r = 1;
memset(h, 60, sizeof(h));
vis[dl[1] = S] = 1, h[S] = 0;
while (l < r) {
int x = dl[++l];
for (int i = ls[x]; i; i = nx[i])
if (f[i]) {
int v = to[i];
if (h[v] > h[x] + vl[i]) {
h[v] = h[x] + vl[i];
be[v] = i;
if (!vis[v]) vis[v] = 1, dl[++r] = v;
}
}
vis[x] = 0;
}
return h[T] < inf;
}
void flow() {
int mn = inf;
for (int i = be[T]; i; i = be[fr[i]]) mn = min(mn, f[i]);
for (int i = be[T]; i; i = be[fr[i]]) f[i] -= mn, f[i ^ 1] += mn;
}
int main() {
int nA, nB, m, K;
scanf("%d %d %d %d", &nA, &nB, &m, &K);
int n = nA + nB;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v), v += nA;
d[u]++, d[v]++, e[i].u = u, e[i].v = v;
}
int ans = 0;
for (int i = 1; i <= n; ++i) ans += d[i] % K > 0;
S = n + 1, T = S + 1;
for (int k = K; k >= 1; --k) {
memset(ls, 0, sizeof(ls)), num = 1;
for (int i = 1; i <= m; ++i)
if (!col[i]) link(e[i].u, e[i].v, 1, 0);
for (int i = 1; i <= nA; ++i) {
link(S, i, d[i] / k, 0);
if (d[i] % k) link(S, i, 1, 1);
}
for (int i = nA + 1; i <= n; ++i) {
link(i, T, d[i] / k, 0);
if (d[i] % k) link(i, T, 1, 1);
}
while (bfs()) flow();
int t = 0;
for (int i = 1; i <= m; ++i)
if (!col[i]) {
t += 2;
if (!f[t]) col[i] = k, d[e[i].u]--, d[e[i].v]--;
}
}
printf("%d\n", ans);
for (int i = 1; i <= m; ++i) printf("%d ", col[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20005;
vector<pair<int, int>> v[N];
int n1, n2, m, kk, clr[N], deg[N], cur[N], idx;
void dfs(int pos, int c1, int c2) {
clr[v[pos][c1].second] = c2;
swap(v[pos][c1], v[pos][c2]);
if (v[pos][c2].first) dfs(v[pos][c2].first, c2, c1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n1 >> n2 >> m >> kk;
for (int i = 1; i <= m; i++) {
int t1, t2;
cin >> t1 >> t2;
t2 += n1;
if (deg[t1] % kk == 0) v[cur[t1] = ++idx].resize(kk);
++deg[t1];
t1 = cur[t1];
if (deg[t2] % kk == 0) v[cur[t2] = ++idx].resize(kk);
++deg[t2];
t2 = cur[t2];
int c1 = -1;
for (int i = 0; i < kk; i++)
if (!v[t1][i].first) c1 = i;
if (v[t2][c1].first) {
int c2 = -1;
for (int i = 0; i < kk; i++)
if (!v[t2][i].first) c2 = i;
dfs(t2, c1, c2);
}
v[t1][c1] = {t2, i};
v[t2][c1] = {t1, i};
clr[i] = c1;
}
int ans = 0;
for (int i = 1; i <= n1 + n2; i++) ans += !!(deg[i] % kk);
cout << ans << endl;
for (int i = 1; i <= m; i++) cout << clr[i] + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int V = 2 * N + 5;
const int E = 1000500;
const int INF = (int)1e9;
struct Edge {
int to, flow, cap, ref;
Edge() : to(), flow(), cap(), ref() {}
Edge(int _to, int _cap, int _ref) : to(_to), flow(), cap(_cap), ref(_ref) {}
};
int go[V];
Edge e[E];
int vcnt, ecnt;
int fake_gs, fake_gt;
int gs, gt;
void add_edge(int a, int b, int cap) {
e[ecnt] = Edge(b, cap, go[a]);
go[a] = ecnt++;
e[ecnt] = Edge(a, 0, go[b]);
go[b] = ecnt++;
}
void modify_edge(int a, int b, int lower_cap, int upper_cap) {
add_edge(gs, b, lower_cap);
add_edge(a, gt, lower_cap);
add_edge(a, b, upper_cap - lower_cap);
}
int cur_go[V];
int dist[V];
int q[V];
int ql, qr;
bool bfs() {
copy(go, go + vcnt, cur_go);
fill(dist, dist + vcnt, INF);
dist[gs] = 0;
ql = qr = 0;
q[qr++] = gs;
while (ql < qr) {
int v = q[ql++];
for (int i = go[v]; i != -1; i = e[i].ref) {
if (e[i].flow == e[i].cap) continue;
int to = e[i].to;
if (dist[to] == INF) {
dist[to] = dist[v] + 1;
q[qr++] = to;
}
}
}
return dist[gt] != INF;
}
int dfs(int v, int flow) {
if (v == gt || flow == 0) return flow;
for (int& i = cur_go[v]; i != -1; i = e[i].ref) {
int to = e[i].to;
if (dist[to] != dist[v] + 1) continue;
int ret = dfs(to, min(flow, e[i].cap - e[i].flow));
if (ret > 0) {
e[i].flow += ret;
e[i ^ 1].flow -= ret;
return ret;
}
}
return 0;
}
void find_flow() {
while (bfs())
while (dfs(gs, INF) > 0) {
}
}
int n, m, k, t;
int edge_index[N][N];
bool has_edge[N][N];
int left_deg[N], right_deg[N];
int color[N * N];
void build_network(int cur_t) {
fake_gs = n + m;
fake_gt = fake_gs + 1;
gs = fake_gt + 1;
gt = gs + 1;
vcnt = gt + 1;
ecnt = 0;
fill(go, go + vcnt, -1);
for (int i = 0; i < n; i++)
modify_edge(fake_gs, i, left_deg[i] / cur_t,
(left_deg[i] + cur_t - 1) / cur_t);
for (int i = 0; i < m; i++)
modify_edge(n + i, fake_gt, right_deg[i] / cur_t,
(right_deg[i] + cur_t - 1) / cur_t);
add_edge(fake_gt, fake_gs, INF);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (has_edge[i][j]) add_edge(i, n + j, 1);
}
void process_network(int col) {
for (int i = 0; i < n; i++)
for (int j = go[i]; j != -1; j = e[j].ref) {
if (e[j].to >= n + m) continue;
int to = e[j].to - n;
if (e[j].flow == 1) {
has_edge[i][to] = false;
left_deg[i]--;
right_deg[to]--;
color[edge_index[i][to]] = col;
}
}
}
void solve() {
memset(color, -1, sizeof(color));
scanf("%d%d%d%d", &n, &m, &k, &t);
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
has_edge[a][b] = true;
edge_index[a][b] = i;
left_deg[a]++;
right_deg[b]++;
}
int ans = 0;
for (int i = 0; i < n; i++)
if (left_deg[i] % t != 0) ans++;
for (int i = 0; i < m; i++)
if (right_deg[i] % t != 0) ans++;
int cur_t = t;
for (int i = 0; i < t; i++) {
build_network(cur_t);
cur_t--;
find_flow();
process_network(i);
}
printf("%d\n", ans);
for (int i = 0; i < k; i++) printf("%d ", color[i] + 1);
}
int main() {
solve();
0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5555;
const int N = 205;
int col[2][M][N];
void dfs(int p, int x, int y, int c0, int c1) {
int t = col[p ^ 1][y][c0];
col[p][x][c0] = y;
col[p ^ 1][y][c0] = x;
if (!t) {
col[p ^ 1][y][c1] = 0;
return;
}
dfs(p ^ 1, y, t, c1, c0);
}
int n, m, k, s;
int sz[2][N], id[2][N];
int Id[M][M], ans[M];
int main() {
scanf("%d%d%d%d", &n, &m, &k, &s);
if (s == 1) {
puts("0");
for (int i = (int)(1); i <= (int)(k); i++) printf("1 ");
return 0;
}
int nd = 0, mx = 0;
for (int i = (int)(1); i <= (int)(n); i++) sz[0][i] = s;
for (int i = (int)(1); i <= (int)(m); i++) sz[1][i] = s;
for (int i = (int)(1); i <= (int)(k); i++) {
int x, y;
scanf("%d%d", &x, &y);
if (sz[0][x] == s) sz[0][x] = 0, id[0][x] = ++nd;
sz[0][x]++;
x = id[0][x];
if (sz[1][y] == s) sz[1][y] = 0, id[1][y] = ++nd;
sz[1][y]++;
y = id[1][y];
Id[x][y] = i;
int c0 = 1, c1 = 1;
for (; col[0][x][c0]; c0++)
;
for (; col[1][y][c1]; c1++)
;
mx = max(mx, max(c0, c1));
if (c0 == c1) {
col[0][x][c0] = y;
col[1][y][c0] = x;
} else
dfs(0, x, y, c0, c1);
}
int mn = 0;
for (int i = (int)(1); i <= (int)(n); i++) mn += (sz[0][i] != s);
for (int i = (int)(1); i <= (int)(m); i++) mn += (sz[1][i] != s);
printf("%d\n", mn);
for (int i = (int)(1); i <= (int)(nd); i++)
for (int j = (int)(1); j <= (int)(mx); j++)
if (col[0][i][j]) ans[Id[i][col[0][i][j]]] = j;
for (int i = (int)(1); i <= (int)(k); i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class Z>
inline bool checkmax(Z &a, Z b) {
if (a == -1 || a < b) {
a = b;
return true;
}
return false;
}
template <class Z>
inline bool checkmin(Z &a, Z b) {
if (a == -1 || a > b) {
a = b;
return true;
}
return false;
}
int ne, nv, s, t;
int size, net[1100];
struct EDGE {
int v, next;
int cap;
int flow;
int idx;
} edge[110000];
void init() {
size = 0;
memset(net, -1, sizeof(net));
}
void add(int u, int v, int cap, int idx) {
edge[size].v = v;
edge[size].cap = cap;
edge[size].flow = 0;
edge[size].next = net[u];
edge[size].idx = idx;
net[u] = size;
++size;
edge[size].v = u;
edge[size].cap = 0;
edge[size].flow = 0;
edge[size].next = net[v];
edge[size].idx = idx;
net[v] = size;
++size;
}
int gap[1100];
int dist[1100];
int pre[1100];
int curedge[1100];
int ISAP(int s, int t) {
int cur_flow, u, temp, neck, i;
int max_flow;
memset(gap, 0, sizeof(gap));
memset(pre, -1, sizeof(pre));
memset(dist, 0, sizeof(dist));
for (i = 1; i <= nv; i++) curedge[i] = net[i];
gap[nv] = nv;
max_flow = 0;
u = s;
while (dist[s] < nv) {
if (u == t) {
cur_flow = 99999999;
for (i = s; i != t; i = edge[curedge[i]].v) {
if (cur_flow > edge[curedge[i]].cap) {
neck = i;
cur_flow = edge[curedge[i]].cap;
}
}
for (i = s; i != t; i = edge[curedge[i]].v) {
temp = curedge[i];
edge[temp].cap -= cur_flow;
edge[temp].flow += cur_flow;
temp ^= 1;
edge[temp].cap += cur_flow;
edge[temp].flow -= cur_flow;
}
max_flow += cur_flow;
u = neck;
}
for (i = curedge[u]; i != -1; i = edge[i].next)
if (edge[i].cap > 0 && dist[u] == dist[edge[i].v] + 1) break;
if (i != -1) {
curedge[u] = i;
pre[edge[i].v] = u;
u = edge[i].v;
} else {
if (0 == --gap[dist[u]]) break;
curedge[u] = net[u];
for (temp = nv, i = net[u]; i != -1; i = edge[i].next)
if (edge[i].cap > 0)
temp = temp < dist[edge[i].v] ? temp : dist[edge[i].v];
dist[u] = temp + 1;
++gap[dist[u]];
if (u != s) u = pre[u];
}
}
return max_flow;
}
struct Fight {
int x, y, idx;
} fight[5100];
int dx[210], dy[210];
int main() {
int i, j, h;
int n, m, k, q;
int a, b, c;
int ss, tt;
while (scanf("%d%d%d%d", &n, &m, &k, &q) != EOF) {
memset(dx, 0, sizeof(dx));
memset(dy, 0, sizeof(dy));
for (i = 1; i <= k; i++) {
scanf("%d%d", &fight[i].x, &fight[i].y);
fight[i].idx = -1;
dx[fight[i].x]++;
dy[fight[i].y]++;
}
int ans = 0;
for (i = 1; i <= n; i++)
if (dx[i] % q) ans++;
for (j = 1; j <= m; j++)
if (dy[j] % q) ans++;
int res = 0;
s = n + m + 1;
t = n + m + 2;
ss = n + m + 3;
tt = n + m + 4;
nv = tt;
for (i = 1; i <= q; i++) {
init();
add(t, s, 99999999, -1);
for (j = 1; j <= n; j++) {
a = dx[j] / (q - i + 1);
b = (dx[j] + q - i) / (q - i + 1);
add(s, j, b - a, -1);
add(s, tt, a, -1);
add(ss, j, a, -1);
}
for (j = 1; j <= m; j++) {
a = dy[j] / (q - i + 1);
b = (dy[j] + q - i) / (q - i + 1);
add(j + n, t, b - a, -1);
add(j + n, tt, a, -1);
add(ss, t, a, -1);
}
for (j = 1; j <= k; j++) {
if (fight[j].idx == -1) add(fight[j].x, fight[j].y + n, 1, j);
}
res += ISAP(ss, tt);
for (int u = 1; u <= n; u++) {
for (j = net[u]; j != -1; j = edge[j].next) {
if (edge[j].idx != -1 && edge[j].cap == 0) {
fight[edge[j].idx].idx = i;
dx[u]--;
dy[edge[j].v - n]--;
}
}
}
}
printf("%d\n", ans);
for (i = 1; i <= k; i++) {
printf("%d", fight[i].idx);
if (i == k)
printf("\n");
else
printf(" ");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305, Q = (1 << 21) + 1;
char in[Q], *is = in, *it = in, c;
void R(int &n) {
for (n = 0; (c = (it == is ? it = (is = in) + fread(in, 1, Q, stdin),
(it == is ? EOF : *is++) : *is++)) < '0' ||
c > '9';)
;
for (; c <= '9' && c >= '0';
c = (it == is ? it = (is = in) + fread(in, 1, Q, stdin),
(it == is ? EOF : *is++) : *is++))
n = n * 10 + c - 48;
}
int na, nb, m, k, x, y, du[N * 2], ans, be[N * N], w[N], w2[N], kk, c1, c2;
int js, g[N * 2], id[10005][305], f[10005][305];
void rv(int x, int c1, int c2) {
swap(f[x][c1], f[x][c2]);
swap(id[x][c1], id[x][c2]);
be[id[x][c2]] = c2;
if (f[x][c2]) rv(f[x][c2], c2, c1);
}
int main() {
R(na);
R(nb);
R(m);
R(k);
for (int i = 1, _e = m; i <= _e; i++) {
R(x);
R(y);
du[x]++;
du[y + na]++;
if (g[x] % k == 0) w[x] = ++js;
if (g[na + y] % k == 0) w2[y] = ++js;
g[x]++;
g[na + y]++;
x = w[x];
y = w2[y];
c1 = 0, c2 = 0;
for (int j = 1, _e = k; j <= _e; j++)
if (!f[x][j]) {
c1 = j;
break;
}
for (int j = 1, _e = k; j <= _e; j++)
if (!f[y][j]) {
c2 = j;
break;
}
if (f[y][c1]) rv(y, c1, c2);
f[x][c1] = y;
id[x][c1] = i;
f[y][c1] = x;
id[y][c1] = i;
be[i] = c1;
}
for (int i = 1, _e = na + nb; i <= _e; i++) ans += (du[i] % k > 0);
printf("%d\n", ans);
for (int i = 1, _e = m; i <= _e; i++) printf("%d ", be[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int Data, Weight, Cost, Next;
};
const int inf = 1000000000;
int G[402];
Edge E[20000];
void Add(int Number, int X, int Y, int W, int C) {
E[Number * 2] = (Edge){Y, W, C, G[X]};
G[X] = Number * 2;
E[Number * 2 + 1] = (Edge){X, 0, -C, G[Y]};
G[Y] = Number * 2 + 1;
}
bool SPFA(int S, int T, int N) {
static int Dist[402], Pre[402], Queue[402];
static bool Flag[402];
for (int i = 0; i < N; i++) Dist[i] = inf;
Dist[S] = 0;
memset(Flag, 0, sizeof(Flag));
int F = 0, R = 1;
Queue[0] = S;
while (F != R) {
int V = Queue[F++], P = G[V];
Flag[V] = false;
if (F == N) F = 0;
while (P != -1) {
int U = E[P].Data;
if (Dist[V] + E[P].Cost < Dist[U] && E[P].Weight) {
Dist[U] = Dist[V] + E[P].Cost;
Pre[U] = P;
if (!Flag[U]) Flag[Queue[R++] = U] = true;
if (R == N) R = 0;
}
P = E[P].Next;
}
}
if (Dist[T] == inf) return false;
int V = T;
while (V != S) {
E[Pre[V]].Weight--;
E[Pre[V] ^ 1].Weight++;
V = E[Pre[V] ^ 1].Data;
}
return true;
}
int main() {
int M, N, K, Total;
scanf("%d%d%d%d", &M, &N, &K, &Total);
static int X[5000], Y[5000], Dx[200], Dy[200];
for (int i = 0; i < K; i++) {
scanf("%d%d", &X[i], &Y[i]);
Dx[--X[i]]++;
Dy[--Y[i]]++;
}
int Ans = 0;
for (int i = 0; i < M; i++)
if (Dx[i] % Total) Ans++;
for (int i = 0; i < N; i++)
if (Dy[i] % Total) Ans++;
printf("%d\n", Ans);
static int Number[5000];
memset(Number, 0, sizeof(Number));
for (int Current = Total; Current; Current--) {
int S = M + N, T = M + N + 1, Count = K;
for (int i = 0; i < M + N + 2; i++) G[i] = -1;
for (int i = 0; i < K; i++)
if (!Number[i]) Add(i, X[i], M + Y[i], 1, 0);
for (int i = 0; i < N; i++) {
Add(Count++, M + i, T, Dy[i] / Current, 0);
if (Dy[i] % Current) Add(Count++, M + i, T, 1, 1);
}
for (int i = 0; i < M; i++) {
Add(Count++, S, i, Dx[i] / Current, 0);
if (Dx[i] % Current) Add(Count++, S, i, 1, 1);
}
while (SPFA(S, T, M + N + 2))
;
for (int i = 0; i < K; i++)
if (!Number[i] && !E[i * 2].Weight) {
Number[i] = Current;
Dx[X[i]]--;
Dy[Y[i]]--;
}
}
for (int i = 0; i < K; i++) {
printf("%d", Number[i]);
putchar((i == K - 1) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double pi = acos(-1.0);
const int N = 5555;
const int INF = (int)1e9;
int u[N], v[N], n, m, k, deg[N], st, fin, st2, fin2, t, color[N];
bool used[N];
struct edge {
int tov, c, num, rev, f;
edge(int tov, int c, int num, int rev)
: tov(tov), c(c), num(num), rev(rev), f(0) {}
};
vector<edge> adj[N];
void add_edge(int u, int v, int c, int num) {
int unum = ((int)(adj[u]).size()), vnum = ((int)(adj[v]).size());
adj[u].push_back(edge(v, c, num, vnum));
adj[v].push_back(edge(u, 0, -1, unum));
}
void add_edge(int u, int v, int l, int r, int num) {
add_edge(st2, v, l, num);
add_edge(u, fin2, l, num);
add_edge(u, v, r - l, num);
}
bool dfs(int v) {
if (v == fin2) return true;
if (used[v]) return false;
used[v] = true;
for (int i = 0; i < ((int)(adj[v]).size()); ++i)
if ((adj[v][i].c - adj[v][i].f > 0) && dfs(adj[v][i].tov)) {
adj[v][i].f++;
adj[adj[v][i].tov][adj[v][i].rev].f--;
return true;
}
return false;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &t);
st = n + m, fin = n + m + 1, st2 = n + m + 2, fin2 = n + m + 3;
for (int i = 0; i < k; ++i) {
scanf("%d%d", &u[i], &v[i]), --u[i], --v[i], v[i] += n;
deg[u[i]]++, deg[v[i]]++;
color[i] = -1;
}
int sum = 0;
for (int i = 0; i < n + m; ++i) sum += (deg[i] + t - 1) / t - (deg[i] / t);
for (int it = 0; it < t; ++it) {
for (int i = 0; i < n + m + 4; ++i) adj[i].clear();
for (int i = 0; i < n; ++i)
add_edge(st, i, deg[i] / (t - it), (deg[i] + (t - it - 1)) / (t - it),
-1);
for (int i = n; i < n + m; ++i)
add_edge(i, fin, deg[i] / (t - it), (deg[i] + (t - it - 1)) / (t - it),
-1);
add_edge(fin, st, INF, -1);
for (int i = 0; i < k; ++i) {
if (color[i] != -1) continue;
add_edge(u[i], v[i], 1, i);
}
while (true) {
memset(used, 0, sizeof(used));
if (!dfs(st2)) break;
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < ((int)(adj[i]).size()); ++j)
if ((adj[i][j].f == 1) && (adj[i][j].num != -1)) {
deg[i]--, deg[adj[i][j].tov]--;
color[adj[i][j].num] = it;
}
}
printf("%d\n", sum);
for (int i = 0; i < k; ++i) printf("%d%c", color[i] + 1, " \n"[i == k - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int L = 1 << 15;
char ibuf[L | 1], *iS = ibuf, *iT = ibuf, obuf[L | 1], *oS = obuf,
*oT = obuf + L, c, st[66];
int tp = 0, f;
inline char gc() {
if (iS == iT) iT = (iS = ibuf) + fread(ibuf, sizeof(char), L, stdin);
return (*iS++);
}
inline void flush() {
fwrite(obuf, sizeof(char), oS - obuf, stdout);
oS = obuf;
}
inline void pc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline long long read() {
long long x = 0;
f = 1, c = gc();
for (; !isdigit(c); c = gc())
if (c == '-') f = -1;
for (; isdigit(c); c = gc()) x = (x << 1) + (x << 3) + (c & 15);
return x * f;
}
inline void write(long long x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) pc(st[tp--]);
}
inline void writeln(long long x) {
write(x);
pc('\n');
}
struct IOflusher {
~IOflusher() { flush(); }
} _ioflusher_;
} // namespace IO
using IO::gc;
using IO::pc;
using IO::read;
using IO::write;
using IO::writeln;
int col[2][5555][5555];
void dfs(int p, int x, int y, int c0, int c1) {
int t = col[p ^ 1][y][c0];
col[p][x][c0] = y;
col[p ^ 1][y][c0] = x;
if (!t) {
col[p ^ 1][y][c1] = 0;
return;
}
dfs(p ^ 1, y, t, c1, c0);
}
const int E = 1e5 + 5;
int n, m, k, s, ans[E];
int sz[2][205], id[2][205];
map<int, int> Id[5555];
int main() {
n = read(), m = read(), k = read(), s = read();
if (s == 1) {
pc('0'), pc('\n');
for (register int i = (1); i <= int(k); ++i) pc('1'), pc(' ');
return 0;
}
int nd = 0, mx = 0;
for (register int i = (1); i <= int(n); ++i) sz[0][i] = s;
for (register int i = (1); i <= int(m); ++i) sz[1][i] = s;
for (register int i = (1); i <= int(k); ++i) {
int x = read(), y = read();
if (sz[0][x] == s) sz[0][x] = 0, id[0][x] = ++nd;
sz[0][x]++;
x = id[0][x];
if (sz[1][y] == s) sz[1][y] = 0, id[1][y] = ++nd;
sz[1][y]++;
y = id[1][y];
Id[x][y] = i;
int c0 = 1, c1 = 1;
for (; col[0][x][c0]; ++c0)
;
for (; col[1][y][c1]; ++c1)
;
mx = max(mx, max(c0, c1));
if (c0 == c1) {
col[0][x][c0] = y;
col[1][y][c0] = x;
} else
dfs(0, x, y, c0, c1);
}
int mn = 0;
for (register int i = (1); i <= int(n); ++i) mn += sz[0][i] != s;
for (register int i = (1); i <= int(m); ++i) mn += sz[1][i] != s;
writeln(mn);
for (register int i = (1); i <= int(nd); ++i)
for (register int j = (1); j <= int(mx); ++j) {
if (col[0][i][j]) ans[Id[i][col[0][i][j]]] = j;
}
for (register int i = (1); i <= int(k); ++i) write(ans[i]), pc(' ');
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3F3F3F3F;
struct edg {
int v, c, i;
edg *e, *f, *g;
} GR[(5000 + 200 * 4 + 1) * 2], *GS = GR, *GT, *GA[(200 * 2 + 3)],
*GC[(200 * 2 + 3)];
inline void edg_ins(int u, int v, int c, int i = 0) {
if (c) {
if (GA[u]) GA[u]->f = GS;
*GS = (edg){v, c, i, GA[u], NULL, GS + 1}, GA[u] = GS++;
if (GA[v]) GA[v]->f = GS;
*GS = (edg){u, 0, 0, GA[v], NULL, GS - 1}, GA[v] = GS++;
}
}
inline void edg_del(edg *e) {
if (e->e) e->e->f = e->f;
if (e->f) e->f->e = e->e;
if (e == GA[e->g->v]) GA[e->g->v] = e->e;
if (e->g->e) e->g->e->f = e->g->f;
if (e->g->f) e->g->f->e = e->g->e;
if (e->g == GA[e->v]) GA[e->v] = e->g->e;
}
int V, Ql, Qr, Q[(200 * 2 + 3)], dis[(200 * 2 + 3)];
inline bool bfs(const int &s, const int &t) {
int u;
edg *e;
memset(dis, -1, V * sizeof(int));
Ql = Qr = -1, dis[Q[++Qr] = s] = 0;
while (Ql < Qr)
for (e = GA[u = Q[++Ql]]; e; e = e->e)
if (e->c && !~dis[e->v]) dis[Q[++Qr] = e->v] = dis[u] + 1;
return ~dis[t];
}
inline int dfs(const int &s, int u, int c = INF) {
if (u == s || c == 0) return c;
int f = 0, d;
for (edg *e = GC[u]; e && c; e = e->e)
if (dis[u] == dis[e->v] + 1 && (d = dfs(s, e->v, std::min(c, e->g->c))))
e->c += d, e->g->c -= d, f += d, c -= d;
if (c) dis[u] = -1;
return f;
}
inline void dnc(const int &s, const int &t) {
for (; bfs(s, t); dfs(s, t)) memcpy(GC, GA, V * sizeof(edg *));
}
int M, N, E, K, i, u, v, s, t, b, c, f, sum, a[5000 + 1], d[200 * 2 + 1];
edg *e;
int main() {
scanf("%d %d %d %d", &M, &N, &E, &K);
s = M + N + 1, t = s + 1, V = t + 1;
for (i = 1; i <= E; ++i)
scanf("%d %d", &u, &v), edg_ins(u, M + v, 1, i), a[i] = 1, ++d[u],
++d[M + v];
for (u = 1; u <= M + N; ++u) sum += bool(d[u] % K);
printf("%d\n", sum);
GT = GS;
for (; K > 1; --K) {
GS = GT, f = 0;
for (e = GA[0]; e; e = e->e) edg_del(e);
for (e = GA[s]; e; e = e->e) edg_del(e);
for (e = GA[t]; e; e = e->e) edg_del(e);
for (u = 1; u <= M; ++u)
b = d[u] / K, c = (d[u] + K - 1) / K, edg_ins(s, u, b),
edg_ins(0, u, c - b), f -= b;
for (v = M + 1; v <= M + N; ++v)
b = d[v] / K, c = (d[v] + K - 1) / K, edg_ins(v, t, b),
edg_ins(v, 0, c - b), f += b;
if (f > 0)
edg_ins(s, 0, +f);
else if (f < 0)
edg_ins(0, t, -f);
dnc(s, t);
for (u = 1; u <= M; ++u)
for (e = GA[u]; e; e = e->e)
if (e->i && !e->c) a[e->i] = K, --d[u], --d[e->v], edg_del(e);
}
for (i = 1; i <= E; ++i) printf("%d%c", a[i], i < E ? ' ' : '\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 20 | 1;
inline char gc() {
static char ibuf[RLEN], *ib, *ob;
(ib == ob) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ib == ob) ? EOF : *ib++;
}
inline int read() {
char ch = gc();
int res = 0;
bool f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
inline long long readll() {
char ch = gc();
long long res = 0;
bool f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
inline int readstring(char *s) {
int top = 0;
char ch = gc();
while (isspace(ch)) ch = gc();
while (!isspace(ch) && ch != EOF) s[++top] = ch, ch = gc();
return top;
}
template <typename tp>
inline void chemx(tp &a, tp b) {
a < b ? a = b : 0;
}
template <typename tp>
inline void chemn(tp &a, tp b) {
a > b ? a = b : 0;
}
const int N = 205, M = 10005;
int con[2][M][505];
int d[2][M], id[2][N];
int E[N][N], ans[M], bel[M];
int n1, n2, m, k, lim, tot;
void dfs(int pos, int u, int v, int cu, int cv) {
int t = con[pos ^ 1][v][cu];
con[pos ^ 1][v][cu] = u;
con[pos][u][cu] = v;
if (!t) {
con[pos ^ 1][v][cv] = 0;
return;
}
dfs(pos ^ 1, v, t, cv, cu);
}
int main() {
n1 = read(), n2 = read(), m = read(), k = read();
for (int i = 1; i <= n1; i++) id[0][i] = ++tot, bel[tot] = i;
for (int i = 1; i <= n2; i++) id[1][i] = ++tot, bel[tot] = i;
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
E[u][v] = i;
if (d[0][u] == k) d[0][u] = 0, id[0][u] = ++tot, bel[tot] = u;
d[0][u]++, u = id[0][u];
if (d[1][v] == k) d[1][v] = 0, id[1][v] = ++tot, bel[tot] = v;
d[1][v]++, v = id[1][v];
int cu = 1, cv = 1;
while (con[0][u][cu]) cu++;
while (con[1][v][cv]) cv++;
chemx(lim, max(cu, cv));
if (cu == cv)
con[0][u][cu] = v, con[1][v][cv] = u;
else
dfs(0, u, v, cu, cv);
}
int res = 0;
for (int i = 1; i <= n1; i++)
if (d[0][i] != k && d[0][i] != 0) res++;
for (int j = 1; j <= n2; j++)
if (d[1][j] != k && d[1][j] != 0) res++;
cout << res << '\n';
for (int i = 1; i <= tot; i++)
for (int j = 1; j <= lim; j++)
if (con[0][i][j]) ans[E[bel[i]][bel[con[0][i][j]]]] = j;
for (int i = 1; i <= m; i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 30011;
const int Maxm = 400111;
const int inf = 1e9;
struct ZKW_flow {
int st, ed, ecnt, n;
int head[Maxn];
int cap[Maxm], cost[Maxm], to[Maxm], next[Maxm];
void init() {
memset(head, -1, sizeof(head));
ecnt = 2;
}
void add(int u, int v, int cc, int ww) {
cap[ecnt] = cc;
cost[ecnt] = ww;
to[ecnt] = v;
next[ecnt] = head[u];
head[u] = ecnt++;
cap[ecnt] = 0;
cost[ecnt] = -ww;
to[ecnt] = u;
next[ecnt] = head[v];
head[v] = ecnt++;
}
int dis[Maxn];
void SPFA() {
for (int i = 0; i <= n; ++i) dis[i] = inf;
priority_queue<pair<int, int> > Q;
dis[st] = 0;
Q.push(make_pair(0, st));
while (!Q.empty()) {
int u = Q.top().second, d = -Q.top().first;
Q.pop();
if (dis[u] != d) continue;
for (int p = head[u]; p != -1; p = next[p]) {
int& v = to[p];
if (cap[p] && dis[v] > d + cost[p]) {
dis[v] = d + cost[p];
Q.push(make_pair(-dis[v], v));
}
}
}
for (int i = 0; i <= n; ++i) dis[i] = dis[ed] - dis[i];
}
int minCost, maxFlow;
bool use[Maxn];
int add_flow(int u, int flow) {
if (u == ed) {
maxFlow += flow;
minCost += dis[st] * flow;
return flow;
}
use[u] = true;
int now = flow;
for (int p = head[u]; p != -1; p = next[p]) {
int& v = to[p];
if (cap[p] && !use[v] && dis[u] == dis[v] + cost[p]) {
int tmp = add_flow(v, min(now, cap[p]));
cap[p] -= tmp;
cap[p ^ 1] += tmp;
now -= tmp;
if (!now) break;
}
}
return flow - now;
}
bool modify_label() {
int d = inf;
for (int u = 0; u <= n; ++u)
if (use[u])
for (int p = head[u]; p != -1; p = next[p]) {
int& v = to[p];
if (cap[p] && !use[v]) d = min(d, dis[v] + cost[p] - dis[u]);
}
if (d == inf) return false;
for (int i = 0; i <= n; ++i)
if (use[i]) dis[i] += d;
return true;
}
int ZKW(int ss, int tt, int nn) {
st = ss, ed = tt, n = nn;
minCost = maxFlow = 0;
SPFA();
while (true) {
while (true) {
for (int i = 0; i <= n; ++i) use[i] = 0;
if (!add_flow(st, inf)) break;
}
if (!modify_label()) break;
}
return maxFlow;
}
} G;
int a[5001], b[5001], deg[501], l[501];
int col[501][501];
int gas[501][501];
queue<int> q;
map<int, int> mp[501];
int main() {
int n, m, t, k;
scanf("%d %d %d %d", &n, &m, &k, &t);
for (int i = 1; i <= k; i++) {
scanf("%d %d", &a[i], &b[i]);
mp[a[i]][b[i]] = mp[b[i]][a[i]] = 1;
deg[a[i]]++;
deg[n + b[i]]++;
}
int ans = 0;
memset(col, 0, sizeof(col));
for (int i = 1; i <= n + m; i++) ans += (deg[i] % t != 0);
printf("%d\n", ans);
for (int step = t; step; step--) {
G.init();
int src = 0, dst = n + m + 1;
for (int i = 1; i <= n; i++) {
G.add(src, i, deg[i] / step, 0);
if (deg[i] % step) G.add(src, i, 1, 1);
}
for (int i = 1; i <= k; i++)
if (!col[a[i]][b[i]]) G.add(a[i], b[i] + n, 1, 0);
for (int i = 1; i <= m; i++) {
G.add(n + i, dst, deg[n + i] / step, 0);
if (deg[n + i] % step) G.add(n + i, dst, 1, 1);
}
G.ZKW(src, dst, dst + 1);
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int j = G.head[x]; j != -1; j = G.next[j]) {
int y = G.to[j], z = G.cap[j];
if (y < x) continue;
if (1 <= x && x <= n) {
if (z) continue;
if (col[x][y - n]) continue;
col[x][y - n] = step;
if (mp[x][y - n]) deg[x]--, deg[y]--;
continue;
} else
q.push(y);
}
}
}
for (int i = 1; i <= k; i++) {
printf("%d ", col[a[i]][b[i]]);
}
}
|
#include <bits/stdc++.h>
const int maxp = 500, maxe = 20000;
using namespace std;
vector<int> as[300], bs[300];
int da[300], db[300];
int n, m, k, t;
int p[maxp], ne[maxe], e[maxe], ev[maxe], ew[maxe], ec;
int S = 1, T = 2;
int nowchooser;
struct edge {
int a, b, flag;
} es[maxe];
map<pair<int, int>, int> fp;
int cuteec;
void adde(int a, int b, int v, int w) {
e[++ec] = b;
ne[ec] = p[a];
p[a] = ec;
ev[ec] = v;
ew[ec] = w;
}
void addde(int a, int b, int v, int w) {
adde(a, b, v, w);
adde(b, a, 0, -w);
}
void clg() {
int i;
ec = 1;
for (i = 0; i < maxp; i++) p[i] = 0;
}
void mkgraph() {
int i;
for (i = 1; i <= n; i++) {
addde(S, 2 + i, da[i] / t, 0);
if (da[i] % t != 0) addde(S, 2 + i, 1, 1);
}
for (i = 1; i <= m; i++) {
addde(2 + n + i, T, db[i] / t, 0);
if (db[i] % t != 0) addde(2 + n + i, T, 1, 1);
}
for (i = 0; i < cuteec; i++)
if (es[i].flag == -1) addde(2 + es[i].a, 2 + n + es[i].b, 1, 0);
}
int l[maxe * 10], fa[maxe * 10], fae[maxe * 10], op, cl;
int pv[maxp], last[maxp];
inline bool isin(const int& a, const int& b, const int& c) {
return a >= b && a <= c;
}
int spfa() {
int i;
for (int i = 0; i < maxp; i++) pv[i] = 1 << 25;
fa[T] = -1;
for (last[S] = pv[l[op = cl = 0] = S] = 0; op <= cl; op++) {
int a = l[op];
for (i = p[a]; i; i = ne[i]) {
if (pv[e[i]] > pv[a] + ew[i] && ev[i] > 0) {
pv[l[++cl] = e[i]] = pv[a] + ew[i];
fa[e[i]] = a;
fae[e[i]] = i;
}
}
}
if (fa[T] == -1) return 0;
int minl = 1 << 25;
for (i = T; fa[i] != 0; i = fa[i]) minl = min(ev[fae[i]], minl);
for (i = T; fa[i] != 0; i = fa[i]) {
if (isin(i, 3, 3 + n - 1) && isin(fa[i], 3 + n, 3 + n + m - 1)) {
int a = i - 2, b = fa[i] - 2 - n;
es[fp[make_pair(a, b)]].flag = -1;
da[a]++;
db[b]++;
} else if (isin(i, 3 + n, 3 + n + m - 1) && isin(fa[i], 3, 3 + n - 1)) {
int a = fa[i] - 2, b = i - 2 - n;
es[fp[make_pair(a, b)]].flag = nowchooser;
da[a]--;
db[b]--;
}
ev[fae[i]] -= minl;
ev[fae[i] ^ 1] += minl;
}
return 1;
}
void flow() {
while (spfa())
;
}
void calc() {
for (t++; --t;) {
nowchooser++;
clg();
mkgraph();
flow();
}
}
int main() {
int i, ans = 0;
scanf("%d%d%d%d", &n, &m, &k, &t);
for (i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
as[a].push_back(b);
bs[b].push_back(a);
es[cuteec].flag = -1;
es[cuteec].a = a;
es[cuteec++].b = b;
fp[make_pair(a, b)] = i;
}
for (i = 1; i <= n; i++) ans += ((da[i] = as[i].size()) % t) != 0;
for (i = 1; i <= m; i++) ans += ((db[i] = bs[i].size()) % t) != 0;
printf("%d\n", ans);
calc();
for (i = 0; i < k; i++) printf("%d ", es[i].flag);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pi = pair<int, int>;
const int MAXN = 5005;
const int MAXM = 5005;
struct edge_color {
int deg[2][MAXN];
pi has[2][MAXN][205];
int color[MAXM];
int c[2];
void clear(int n) {
for (int t = 0; t < 2; t++) {
for (int i = 0; i <= n; i++) {
deg[t][i] = 0;
for (int j = 0; j <= n; j++) {
has[t][i][j] = pi(0, 0);
}
}
}
}
void dfs(int x, int p) {
auto i = has[p][x][c[!p]];
if (has[!p][i.first][c[p]].second)
dfs(i.first, !p);
else
has[!p][i.first][c[!p]] = pi(0, 0);
has[p][x][c[p]] = i;
has[!p][i.first][c[p]] = pi(x, i.second);
color[i.second] = c[p];
}
int solve(vector<pi> v, vector<int> &cv) {
int m = ((int)(v).size());
int ans = 0;
for (int i = 1; i <= m; i++) {
int x[2];
x[0] = v[i - 1].first;
x[1] = v[i - 1].second;
for (int d = 0; d < 2; d++) {
deg[d][x[d]] += 1;
ans = max(ans, deg[d][x[d]]);
for (c[d] = 1; has[d][x[d]][c[d]].second; c[d]++)
;
}
if (c[0] != c[1]) dfs(x[1], 1);
for (int d = 0; d < 2; d++) has[d][x[d]][c[0]] = pi(x[!d], i);
color[i] = c[0];
}
cv.resize(m);
for (int i = 1; i <= m; i++) {
cv[i - 1] = color[i];
color[i] = 0;
}
return ans;
}
} EC;
int cnt[2][MAXN];
int idx[2][MAXN], L, R;
int main() {
int m, t;
scanf("%*d %*d %d %d", &m, &t);
vector<pi> ans;
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d %d", &l, &r);
if (cnt[0][l] == 0) idx[0][l] = ++L;
if (cnt[1][r] == 0) idx[1][r] = ++R;
cnt[0][l]++;
cnt[1][r]++;
if (cnt[0][l] == t) cnt[0][l] = 0;
if (cnt[1][r] == t) cnt[1][r] = 0;
ans.emplace_back(idx[0][l], idx[1][r]);
}
int ret = 0;
for (int i = 0; i < MAXN; i++) {
ret += (cnt[0][i] > 0);
ret += (cnt[1][i] > 0);
}
cout << ret << endl;
vector<int> color;
EC.solve(ans, color);
for (auto &i : color) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
namespace input {
template <class T>
void re(complex<T>& x);
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
void re(long double& x) {
string t;
re(t);
x = stold(t);
}
template <class T, class... Ts>
void re(T& t, Ts&... ts) {
re(t);
re(ts...);
}
template <class T>
void re(complex<T>& x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = (0); i < ((int)a.size()); ++i) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = (0); i < (SZ); ++i) re(a[i]);
}
} // namespace input
using namespace input;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(long long x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(long double x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template <class T>
void pr(const complex<T>& x) {
cout << x;
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T>
void pr(const T& x);
template <class T, class... Ts>
void pr(const T& t, const Ts&... ts) {
pr(t);
pr(ts...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void pr(const T& x) {
pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
void ps() { pr("\n"); }
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(" ");
ps(ts...);
}
void pc() { pr("]\n"); }
template <class T, class... Ts>
void pc(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(", ");
pc(ts...);
}
} // namespace output
using namespace output;
namespace io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
cin.sync_with_stdio(0);
cin.tie(0);
if ((int)second.size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace io
using namespace io;
typedef decay<decltype(MOD)>::type T;
struct mi {
T val;
explicit operator T() const { return val; }
mi() { val = 0; }
mi(const long long& v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0) val += MOD;
}
friend void pr(const mi& a) { pr(a.val); }
friend void re(mi& a) {
long long x;
re(x);
a = mi(x);
}
friend bool operator==(const mi& a, const mi& b) { return a.val == b.val; }
friend bool operator!=(const mi& a, const mi& b) { return !(a == b); }
friend bool operator<(const mi& a, const mi& b) { return a.val < b.val; }
mi operator-() const { return mi(-val); }
mi& operator+=(const mi& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
mi& operator-=(const mi& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
mi& operator*=(const mi& m) {
val = (long long)val * m.val % MOD;
return *this;
}
friend mi pow(mi a, long long p) {
mi ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mi inv(const mi& a) {
assert(a != 0);
return pow(a, MOD - 2);
}
mi& operator/=(const mi& m) { return (*this) *= inv(m); }
friend mi operator+(mi a, const mi& b) { return a += b; }
friend mi operator-(mi a, const mi& b) { return a -= b; }
friend mi operator*(mi a, const mi& b) { return a *= b; }
friend mi operator/(mi a, const mi& b) { return a /= b; }
};
template <int SZ>
struct Dinic {
typedef long long F;
struct Edge {
int to, rev;
F flow, cap;
};
int N, second, t;
vector<Edge> adj[SZ];
typename vector<Edge>::iterator cur[SZ];
void addEdge(int u, int v, F cap) {
assert(cap >= 0);
Edge a{v, (int)adj[v].size(), 0, cap}, b{u, (int)adj[u].size(), 0, 0};
adj[u].push_back(a), adj[v].push_back(b);
}
int level[SZ];
bool bfs() {
for (int i = (0); i < (N); ++i) level[i] = -1, cur[i] = begin(adj[i]);
queue<int> q({second});
level[second] = 0;
while ((int)q.size()) {
int u = q.front();
q.pop();
for (auto& e : adj[u])
if (level[e.to] < 0 && e.flow < e.cap)
q.push(e.to), level[e.to] = level[u] + 1;
}
return level[t] >= 0;
}
F sendFlow(int v, F flow) {
if (v == t) return flow;
for (; cur[v] != end(adj[v]); cur[v]++) {
Edge& e = *cur[v];
if (level[e.to] != level[v] + 1 || e.flow == e.cap) continue;
auto df = sendFlow(e.to, min(flow, e.cap - e.flow));
if (df) {
e.flow += df;
adj[e.to][e.rev].flow -= df;
return df;
}
}
return 0;
}
F maxFlow(int _N, int _s, int _t) {
N = _N, second = _s, t = _t;
if (second == t) return -1;
F tot = 0;
while (bfs())
while (auto df = sendFlow(second, numeric_limits<F>::max())) tot += df;
return tot;
}
};
Dinic<405> D;
int n, m, k, t, tot;
bool adj[201][201];
int ldeg[201], rdeg[201], ans[201][201];
int ret = 0;
void ae(int x, int y, int l, int r, bool flag) {
if (flag) ret += r - l;
D.addEdge(n + m + 1, y, r);
D.addEdge(y, x, r - l);
D.addEdge(x, n + m + 2, r);
tot += r;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
re(n, m, k, t);
vector<pair<int, int> > ed;
for (int i = (0); i < (k); ++i) {
int x, y;
re(x, y);
ed.push_back({x, y});
adj[x][y] = 1;
}
for (int i = (0); i < (t); ++i) {
D = Dinic<405>();
tot = 0;
for (int a = (1); a < (n + 1); ++a) ldeg[a] = 0;
for (int b = (1); b < (m + 1); ++b) rdeg[b] = 0;
for (int a = (1); a < (n + 1); ++a)
for (int b = (1); b < (m + 1); ++b)
if (adj[a][b]) {
ldeg[a]++, rdeg[b]++;
D.addEdge(a, n + b, 1);
}
for (int a = (1); a < (n + 1); ++a)
ae(0, a, ldeg[a] / (t - i), (ldeg[a] + t - i - 1) / (t - i), i == 0);
for (int b = (1); b < (m + 1); ++b)
ae(n + b, 0, rdeg[b] / (t - i), (rdeg[b] + t - i - 1) / (t - i), i == 0);
assert(D.maxFlow(n + m + 3, n + m + 1, n + m + 2) == tot);
for (int a = (1); a < (n + 1); ++a)
for (auto& t : D.adj[a])
if (n + 1 <= t.to && t.to <= n + m && t.flow) {
adj[a][t.to - n] = 0;
ans[a][t.to - n] = i + 1;
}
}
ps(ret);
for (auto& t : ed) pr(ans[t.first][t.second], ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ft, cp, ed, x, y, lo, hi, SS, TT, S, T, V, ret;
int v[500], l[500], d[500], g[500], ex[50000], ey[50000];
int lbl[500][500], qd[50000], qn[50000], qc[50000];
void bd(int x, int y, int c) {
qd[++ed] = y, qn[ed] = l[x], l[x] = ed, qc[ed] = c;
}
int ISAP(int x, int y) {
int mn = V - 1, F = 0, R = y, t;
if (x == T) return y;
for (int i = l[x]; i; i = qn[i]) {
if (qc[i] > 0) {
if (v[x] == v[qd[i]] + 1) {
t = ISAP(qd[i], min(qc[i], R));
qc[i] -= t;
qc[i ^ 1] += t;
R -= t;
F += t;
if (v[S] >= V) return F;
if (!R) break;
}
mn = min(mn, v[qd[i]]);
}
}
if (!F) {
g[v[x]]--;
if (!g[v[x]]) v[S] = V;
v[x] = mn + 1;
g[v[x]]++;
}
return F;
}
int MaxFlow() {
memset(v, 0, sizeof(v));
memset(g, 0, sizeof(g));
int ret = 0;
g[0] = V;
while (v[S] < V) ret += ISAP(S, 1 << 30);
return ret;
}
int main() {
scanf("%d%d%d%d", &n, &m, &ft, &cp);
memset(lbl, -1, sizeof(lbl));
for (int i = (0); i < (ft); i++) {
scanf("%d%d", &x, &y);
x--, y--;
ex[i] = x, ey[i] = y;
lbl[x][y] = -2;
d[x]++, d[y + n]++;
}
for (int i = (0); i < (n + m); i++) ret += !!(d[i] % cp);
SS = n + m;
TT = SS + 1;
S = TT + 1;
T = S + 1;
V = n + m + 4;
for (int i = (0); i < (cp); i++) {
memset(l, 0, sizeof(l));
ed = 1;
for (int j = (0); j < (n); j++)
for (int k = (0); k < (m); k++)
if (lbl[j][k] == -2) bd(j, k + n, 1), bd(k + n, j, 0);
for (int j = (0); j < (n); j++) {
lo = d[j] / (cp - i);
hi = (d[j] + cp - i - 1) / (cp - i);
bd(SS, j, hi - lo), bd(j, SS, 0);
bd(S, j, lo), bd(j, S, 0);
bd(SS, T, lo), bd(T, SS, 0);
}
for (int j = (n); j < (n + m); j++) {
lo = d[j] / (cp - i);
hi = (d[j] + cp - i - 1) / (cp - i);
bd(j, TT, hi - lo), bd(TT, j, 0);
bd(S, TT, lo), bd(TT, S, 0);
bd(j, T, lo), bd(T, j, 0);
}
bd(S, SS, (1 << 28)), bd(SS, S, 0);
bd(TT, T, (1 << 28)), bd(T, TT, 0);
bd(SS, TT, (1 << 28)), bd(TT, SS, 0);
MaxFlow();
for (int k = (l[S]); k; k = qn[k])
if (qd[k] != SS && qc[k]) printf("UnSatisfy on %d, %d\n", qd[k], i);
for (int j = (0); j < (n); j++)
for (int k = (l[j]); k; k = qn[k])
if (qd[k] >= n && qd[k] < n + m && !qc[k]) {
d[j]--;
d[qd[k]]--;
lbl[j][qd[k] - n] = i;
}
}
printf("%d\n", ret);
for (int i = (0); i < (ft); i++) printf("%d ", lbl[ex[i]][ey[i]] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ne, nc;
const int inff = 0x3f3f3f3f;
const int infc = 0x3f3f3f3f;
const int E = 40000;
const int N = 420;
struct network {
int nv, ne, pnt[E], nxt[E], shou[E], lsh;
int vis[N], que[N + 2], head[N], pv[N], pe[N];
int flow, cap[E];
int cost, dis[E], d[N];
bool can[E];
bool can1[E];
void addedge(int u, int v, int c, int w) {
pnt[ne] = v;
cap[ne] = c;
dis[ne] = +w;
nxt[ne] = head[u];
head[u] = (ne++);
pnt[ne] = u;
cap[ne] = 0;
dis[ne] = -w;
nxt[ne] = head[v];
head[v] = (ne++);
}
int mincost(int src, int sink) {
int i, k, f, r;
int mxf;
lsh = 0;
memset(can1, 0, sizeof(can));
for (flow = 0, cost = 0;;) {
memset(pv, -1, sizeof(pv));
memset(vis, 0, sizeof(vis));
for (i = 0; i < nv; ++i) d[i] = infc;
d[src] = 0;
pv[src] = src;
vis[src] = 1;
for (f = 0, r = 1, que[0] = src; r != f;) {
i = que[f++];
vis[i] = 0;
if (N == f) f = 0;
for (k = head[i]; k != -1; k = nxt[k])
if (!(can[k]) && cap[k] && dis[k] + d[i] < d[pnt[k]]) {
d[pnt[k]] = dis[k] + d[i];
if (0 == vis[pnt[k]]) {
vis[pnt[k]] = 1;
que[r++] = pnt[k];
if (N == r) r = 0;
}
pv[pnt[k]] = i;
pe[pnt[k]] = k;
}
}
if (-1 == pv[sink]) break;
for (k = sink, mxf = inff; k != src; k = pv[k])
if (cap[pe[k]] < mxf) mxf = cap[pe[k]];
flow += mxf;
cost += d[sink] * mxf;
for (k = sink; k != src; k = pv[k]) {
cap[pe[k]] -= mxf;
cap[pe[k] ^ 1] += mxf;
if (pv[k] > k) {
can1[pe[k]] = 1;
can1[pe[k] ^ 1] = 1;
}
shou[lsh++] = pe[k] ^ 1;
}
}
for (i = 0; i < lsh; i++) {
if (can1[shou[i]]) continue;
can[shou[i]] = 1;
can[shou[i] ^ 1] = 1;
}
return cost;
}
} g;
inline void changeedge(int no, int cap, int f) {
if (f) {
g.cap[no] = cap;
g.cap[no + 1] = 0;
g.can[no] = 0;
g.can[no + 1] = 0;
} else {
g.dis[no] = cap;
g.dis[no + 1] = -cap;
g.can[no] = 0;
g.can[no + 1] = 0;
}
}
int capcity[N];
int ans[N][N];
int orig[E][2];
int main() {
memset(ans, -1, sizeof(ans));
scanf("%d%d%d%d", &n, &m, &ne, &nc);
memset(g.head, -1, sizeof(g.head));
for (int i = 0; i < ne; i++) {
int a, b;
scanf("%d%d", &a, &b);
g.addedge(a, b + n, 1, 0);
capcity[a]++;
capcity[b + n]++;
orig[i][0] = a - 1;
orig[i][1] = b - 1;
}
int k = 0;
for (int i = 1; i < n + m + 1; i++)
if (capcity[i] % nc) k++;
printf("%d\n", k);
for (int i = 1; i < n + 1; i++) {
g.addedge(0, i, capcity[i] / nc, 0);
g.addedge(0, i, capcity[i] / nc, 1);
}
for (int i = 1; i < m + 1; i++) {
g.addedge(i + n, n + m + 1, capcity[i + n] / nc, 0);
g.addedge(i + n, n + m + 1, capcity[i + n] / nc, 1);
}
g.nv = n + m + 2;
memset(g.can, 0, sizeof(g.can));
for (int i1 = 0; i1 < nc; i1++) {
int p1 = g.head[0];
while (p1 != -1) {
if (g.dis[p1] == 0)
changeedge(p1, capcity[g.pnt[p1]] / (nc - i1), 1);
else
changeedge(p1, bool(capcity[g.pnt[p1]] % (nc - i1)), 1);
p1 = g.nxt[p1];
}
for (int i = 1; i < m + 1; i++) {
int temph = g.head[i + n];
changeedge(temph, bool(capcity[i + n] % (nc - i1)), 1);
temph = g.nxt[temph];
changeedge(temph, capcity[i + n] / (nc - i1), 1);
temph = 0;
}
k = g.mincost(0, n + m + 1);
for (int i = 1; i < n + 1; i++) {
int ranh = g.head[i];
while (ranh != -1) {
if (g.pnt[ranh] != 0 && g.cap[ranh] == 0 &&
ans[i - 1][g.pnt[ranh] - n - 1] == -1) {
ans[i - 1][g.pnt[ranh] - n - 1] = i1;
capcity[i]--;
capcity[g.pnt[ranh]]--;
g.can[ranh] = 1;
g.can[ranh ^ 1] = 1;
}
ranh = g.nxt[ranh];
}
}
}
for (int i = 0; i < n; i++) {
int col[N], max = -1, min = 100000;
memset(col, 0, sizeof(col));
for (int j = 0; j < m; j++)
if (ans[i][j] != -1) col[ans[i][j]]++;
for (int j = 0; j < nc; j++) {
if (min > col[j]) min = col[j];
if (max < col[j]) max = col[j];
}
if (max > min + 1) {
printf("WA i %d\n", i);
for (int j = 0; j < nc; j++) printf("%d ", col[j]);
return 0;
}
}
for (int i = 0; i < m; i++) {
int col[N], max = -1, min = 100000;
memset(col, 0, sizeof(col));
for (int j = 0; j < n; j++)
if (ans[j][i] != -1) col[ans[j][i]]++;
for (int j = 0; j < nc; j++) {
if (min > col[j]) min = col[j];
if (max < col[j]) max = col[j];
}
if (max > min + 1) {
printf("WA j %d\n", i);
for (int j = 0; j < nc; j++) printf("%d ", col[j]);
return 0;
}
}
for (int i = 0; i < ne; i++) {
while (ans[orig[i][0]][orig[i][1]] == -1)
;
printf("%d ", ans[orig[i][0]][orig[i][1]] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
const int maxn = 11011;
const int maxm = 6011;
const int maxc = 211;
int head[maxn], deg[maxn], nxt[maxm * 2], to[maxm * 2], tot = 1;
vector<pair<int, int> > con[maxn];
void add_edge(int x, int y, int id) {
nxt[++tot] = head[x];
head[x] = tot;
to[tot] = y;
deg[x]++;
swap(x, y);
nxt[++tot] = head[x];
head[x] = tot;
to[tot] = y;
deg[x]++;
}
int match[maxn][maxc];
int n, n1, n2, m, k;
int ans[maxm], lst[maxn];
int find_color(int x) {
for (int i = 1; i <= k; i++)
if (!match[x][i]) return i;
assert(false);
}
void aug(int e, int c, int pc) {
int x = to[e ^ 1], y = to[e];
if (match[y][c])
aug(match[y][c], pc, c);
else
match[y][pc] = 0;
match[x][c] = e;
match[y][c] = e ^ 1;
ans[e >> 1] = c;
}
void solve() {
for (int x = 1; x <= n; x++) {
for (int e = head[x]; e; e = nxt[e]) {
int y = to[e];
if (ans[e >> 1]) continue;
int c = find_color(x);
int pc = find_color(y);
aug(e, c, pc);
}
}
}
int main() {
n1 = getnum(), n2 = getnum();
m = getnum(), k = getnum();
n = n1 + n2;
for (int i = 1; i <= n; i++) lst[i] = i;
for (int i = 1; i <= m; i++) {
int x, y;
x = getnum(), y = getnum();
y += n1;
add_edge(lst[x], lst[y], i);
if (deg[lst[x]] >= k) lst[x] = ++n;
if (deg[lst[y]] >= k) lst[y] = ++n;
}
solve();
int cnt = 0;
for (int i = 1; i <= n1 + n2; i++) cnt += deg[lst[i]] > 0;
putnum(cnt), putchar('\n');
for (int i = 1; i <= m; i++) putnum(ans[i]), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 410, K = 5e3 + 10;
struct Edge {
int u, v;
long long cap, flow;
int id;
Edge() {}
Edge(int u, int v, long long cap, int id)
: u(u), v(v), cap(cap), flow(0), id(id) {}
};
struct Dinic {
int n, m, N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt, lo, side, flowAt;
vector<bool> vis;
Dinic(int n, int m)
: n(n),
m(m),
N(n + m + 2),
E(0),
g(N),
d(N),
pt(N),
lo(N),
side(N),
flowAt(N),
vis(N) {}
void AddEdge(int u, int v, long long cap, int id) {
if (u != v) {
E.emplace_back(Edge(u, v, cap, id));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0, -1));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
bool DFS2(int S, int u) {
if (vis[u]) {
return false;
} else if (side[u] == side[S] and flowAt[u] > lo[u]) {
--flowAt[u];
return true;
}
vis[u] = true;
for (auto k : g[u]) {
auto &e = E[k];
auto &oe = E[k ^ 1];
if (e.flow < e.cap) {
if (DFS2(S, e.v)) {
++e.flow;
--oe.flow;
return true;
}
}
}
return false;
}
bool DFS3(int S, int u) {
if (vis[u]) {
return false;
} else if (side[u] == side[S] and flowAt[u] > lo[u]) {
--flowAt[u];
return true;
}
vis[u] = true;
for (auto k : g[u]) {
auto &e = E[k];
auto &oe = E[k ^ 1];
if (oe.flow < oe.cap) {
if (DFS3(S, e.v)) {
++oe.flow;
--e.flow;
return true;
}
}
}
return false;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
void enforceLowerBounds(int S, int T) {
for (auto &k : g[S]) {
auto &e = E[k];
flowAt[e.v] = e.flow;
side[e.v] = 1;
}
for (auto &k : g[T]) {
auto &e = E[k ^ 1];
flowAt[e.u] = e.flow;
side[e.u] = 2;
}
for (int i = 1; i <= n; ++i) {
while (flowAt[i] < lo[i]) {
fill(vis.begin(), vis.end(), 0);
vis[S] = vis[T] = 1;
assert(DFS2(i, i));
++flowAt[i];
}
}
for (int j = n + 1; j <= n + m; ++j) {
while (flowAt[j] < lo[j]) {
fill(vis.begin(), vis.end(), 0);
vis[S] = vis[T] = 1;
assert(DFS3(j, j));
++flowAt[j];
}
}
}
};
int deg[N], lo[N], hi[N];
int u[K], v[K], type[K];
bool used[K];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, t;
cin >> n >> m >> k >> t;
for (int i = 1; i <= k; ++i) {
cin >> u[i] >> v[i];
v[i] += n;
++deg[u[i]];
++deg[v[i]];
}
int ans = 0;
for (int i = 1; i <= n + m; ++i) {
if (deg[i] % t) {
++ans;
}
}
for (int c = 1; c <= t; ++c) {
Dinic dinic(n, m);
int source = 0, sink = n + m + 1;
memset(deg, 0, sizeof(deg));
for (int i = 1; i <= k; ++i) {
if (!used[i]) {
dinic.AddEdge(u[i], v[i], 1, i);
++deg[u[i]];
++deg[v[i]];
}
}
int cur_t = (t - c + 1);
for (int i = 0; i < dinic.N; ++i) {
lo[i] = deg[i] / cur_t;
hi[i] = (deg[i] + cur_t - 1) / cur_t;
dinic.lo[i] = lo[i];
}
for (int i = 1; i <= n; ++i) {
dinic.AddEdge(source, i, hi[i], -1);
}
for (int j = n + 1; j <= n + m; ++j) {
dinic.AddEdge(j, sink, hi[j], -1);
}
dinic.MaxFlow(source, sink);
dinic.enforceLowerBounds(source, sink);
for (auto &e : dinic.E) {
if (e.id != -1 and e.flow) {
type[e.id] = c;
used[e.id] = true;
}
}
}
cout << ans << '\n';
for (int i = 1; i <= k; ++i) {
cout << type[i] << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dbv;
int p[700], f[700], fi[700], e[600000], ev[600000], ef[600000], ne[600000],
pf[700], ec;
int d1[700], d2[700];
struct edges {
int a, b;
int chooser;
bool operator<(const edges& p) const {
return a < p.a || (a == p.a && b < p.b);
}
bool operator==(const edges& p) const { return a == p.a && b == p.b; }
} es[600000];
map<edges, int> linktable;
int n, m, k, t;
int S, T;
int nowchooser;
void addes(int a, int b, int v, int f) {
e[++ec] = b;
ev[ec] = v;
ef[ec] = f;
ne[ec] = p[a];
p[a] = ec;
}
void adde(int a, int b, int v, int f) {
addes(a, b, v, f);
addes(b, a, 0, -f);
}
void build_g() {
int i;
S = 1, T = 2;
ec = 1;
nowchooser++;
for (i = 0; i < 700; i++) p[i] = f[i] = 0;
for (i = 0; i < k; i++)
if (!es[i].chooser) adde(es[i].a + 7, es[i].b + n + 7, 1, 0);
for (i = 1; i <= n; i++) {
adde(S, i + 7, d1[i] / t, 0);
if (d1[i] % t != 0) adde(S, i + 7, 1, 1);
}
for (i = 1; i <= m; i++) {
adde(i + 7 + n, T, d2[i] / t, 0);
if (d2[i] % t != 0) adde(i + 7 + n, T, 1, 1);
}
}
int l[600000 * 2];
void spfa() {
int op, cl, i;
dbv++;
for (i = 0; i < 700; i++) pf[i] = 1000000;
for (f[S] = pf[l[op = cl = 0] = S] = 0; op <= cl; op++) {
int a = l[op];
for (i = p[a]; i; i = ne[i])
if (pf[e[i]] > pf[a] + ef[i] && ev[i] > 0) {
pf[l[++cl] = e[i]] = pf[a] + ef[i];
f[e[i]] = a;
fi[e[i]] = i;
}
}
}
bool is_in_range(const int a, const int l, const int r) {
return a >= l && a <= r;
}
void resete() {
int minl = 1000000, a;
if (pf[T] == 1000000) return;
for (a = T; f[a]; a = f[a]) minl = min(minl, ev[fi[a]]);
for (a = T; f[a]; a = f[a]) {
if ((!(fi[a] & 1)) && is_in_range(f[a], 7 + 1, 7 + n) &&
is_in_range(a, 7 + 1 + n, 7 + m + n)) {
edges p;
p.a = f[a] - 7;
p.b = a - 7 - n;
assert(es[linktable[p]].chooser == 0);
es[linktable[p]].chooser = nowchooser;
d1[p.a]--;
d2[p.b]--;
}
if (((fi[a] & 1)) && is_in_range(a, 7 + 1, 7 + n) &&
is_in_range(f[a], 7 + 1 + n, 7 + m + n)) {
edges p;
p.a = a - 7;
p.b = f[a] - 7 - n;
assert(es[linktable[p]].chooser != 0);
es[linktable[p]].chooser = 0;
d1[p.a]++;
d2[p.b]++;
}
ev[fi[a]] -= minl;
ev[fi[a] ^ 1] += minl;
}
}
void flow() {
for (pf[T] = 0; pf[T] != 1000000; resete()) spfa();
t--;
}
int calcallans() {
int ans = 0;
for (int i = 1; i <= n; i++) ans += d1[i] % t != 0;
for (int i = 1; i <= m; i++) ans += d2[i] % t != 0;
return ans;
}
int main() {
int allans, i;
scanf("%d%d%d%d", &n, &m, &k, &t);
for (i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
es[i].a = a;
es[i].b = b;
es[i].chooser = 0;
linktable[es[i]] = i;
d1[a]++;
d2[b]++;
}
allans = calcallans();
for (i = t; i; i--) {
build_g();
flow();
}
printf("%d\n", allans);
for (i = 0; i < k; i++)
printf("%d%c", es[i].chooser, (i == k - 1 ? '\n' : ' '));
}
|
#include <bits/stdc++.h>
const int N = 200 + 10, V = 2 * N, E = V * V, INF = 0x3f3f3f3f;
int arc[V], adj[V], to[E], next[E], cap[E], cnt, s, t, ss, tt;
inline void link(int a, int b, int c) {
to[cnt] = b, next[cnt] = adj[a], cap[cnt] = c, adj[a] = cnt++;
to[cnt] = a, next[cnt] = adj[b], cap[cnt] = 0, adj[b] = cnt++;
}
int h[V], gap[V];
int dfs(int a, int df) {
if (a == tt) return df;
int res = 0;
for (int &i = arc[a]; i; i = next[i]) {
int b = to[i];
if (cap[i] && h[a] == h[b] + 1) {
int f = dfs(b, std::min(df - res, cap[i]));
cap[i] -= f;
cap[i ^ 1] += f;
res += f;
}
if (res == df) return res;
}
if (--gap[h[a]] == 0) h[s] = tt + 1;
++gap[++h[a]];
arc[a] = adj[a];
return res;
}
int n, m, k, tot;
int id[N][N], deg[2][N];
int ans[N * N];
void solve(int x) {
cnt = 2;
memset(adj, 0, sizeof adj);
static int tag[N][N];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (id[i][j] && !ans[id[i][j]]) tag[i][j] = cnt, link(i, j + n, 1);
s = n + m + 1;
t = s + 1;
ss = t + 1;
tt = ss + 1;
for (int i = 1; i <= n; ++i) {
link(ss, i, deg[0][i] / x);
link(s, tt, deg[0][i] / x);
if (deg[0][i] % x) link(s, i, 1);
}
for (int i = 1; i <= m; ++i) {
link(ss, t, deg[1][i] / x);
link(i + n, tt, deg[1][i] / x);
if (deg[1][i] % x) link(i + n, t, 1);
}
link(t, s, INF);
memset(h, 0, sizeof h);
memset(gap, 0, sizeof gap);
memcpy(arc, adj, sizeof arc);
int cur = 0;
while (h[s] <= tt) cur += dfs(ss, INF);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (id[i][j] && !ans[id[i][j]] && !cap[tag[i][j]])
--deg[0][i], --deg[1][j], ans[id[i][j]] = x;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &tot);
for (int i = 1; i <= k; ++i) {
int x, y;
scanf("%d%d", &x, &y);
id[x][y] = i;
++deg[0][x], ++deg[1][y];
}
int sum = 0;
for (int i = 1; i <= n; ++i)
if (deg[0][i] % tot) ++sum;
for (int i = 1; i <= m; ++i)
if (deg[1][i] % tot) ++sum;
printf("%d\n", sum);
for (int i = tot; i > 0; --i) solve(i);
for (int i = 1; i <= k; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int alfabet[30] = {};
char string[105];
int i = 0;
int isi;
scanf("%s", string);
for (int i = 0; i < strlen(string); i++) {
alfabet[string[i] - 96]++;
}
for (int i = 0; i < 27; i++) {
if (alfabet[i] != 0) {
isi++;
}
}
if (isi % 2 == 0) {
printf("IGNORE HIM!\n");
} else {
printf("CHAT WITH HER!\n");
}
}
|
#include <bits/stdc++.h>
int main() {
int i = 0, a[100], b[27], s = 0, l;
char c;
c = getchar();
while (c != '\n') {
a[i] = c;
i++;
c = getchar();
}
i--;
for (l = 0; l < 27; l++) b[l] = 0;
for (l = 0; l <= i; l++) b[a[l] - 'a']++;
for (i = 0; i < 27; i++) {
if (b[i] != 0) s++;
}
if (s % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int h = s.size() - 1;
for (int i = 0; i < h; i++) {
for (int j = i + 1; j < s.size(); j++) {
if (s[i] == s[j]) {
s[j] = '?';
}
}
}
int counter = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '?') {
counter++;
}
}
if (counter % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
}
|
#include <bits/stdc++.h>
int main() {
char c[101];
int i, d, n = 1;
scanf("%s", c);
for (i = 1; c[i] != '\0'; i++) {
for (d = 0; d < i; d++) {
if (c[i] == c[d])
break;
else
continue;
}
if (d == i) n++;
}
if (n % 2 == 0)
printf("CHAT WITH HER!");
else
printf("IGNORE HIM!");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> set;
for (auto &x : s) {
set.insert(x);
}
if (set.size() % 2 == 0) {
cout << "CHAT WITH HER!\n";
} else {
cout << "IGNORE HIM!\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
getline(cin, x);
sort(x.begin(), x.end());
int res = unique(x.begin(), x.end()) - x.begin();
if (res % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count[26];
for (int i = 0; i < 26; i++) {
count[i] = 0;
}
int n = s.size();
for (int i = 0; i < n; i++) {
count[s[i] - 'a']++;
}
int c = 0;
for (int i = 0; i < 26; i++) {
if (count[i] != 0) c++;
}
if (c % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> a;
for (int i = int(0); i <= int(s.length() - 1); i++) {
a.insert(s[i]);
}
if (a.size() & 1)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
string str;
cin >> str;
set<char> s;
int len = str.length();
for (int i = 0; i < len; i++) s.insert(str[i]);
int num = s.size();
if (num % 2 == 0)
puts("CHAT WITH HER!");
else
puts("IGNORE HIM!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int count = 0;
cin >> s;
sort(s.begin(), s.end());
for (int i = 0; i < s.length(); i++) {
if (s[i] != s[i + 1]) count++;
}
if (count % 2 == 1)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> set1;
char a[100];
cin >> a;
set1.insert(a, a + (strlen(a)));
if (set1.size() % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else {
cout << "IGNORE HIM!" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int maxn = 1 << 17;
const int inf = 1000000007;
const int mod = 1000000007;
int main() {
string s;
set<char> a;
cin >> s;
for (int i = 0; i < s.length(); i++) a.insert(s[i]);
cout << (a.size() & 1 ? "IGNORE HIM!" : "CHAT WITH HER!") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
for (int i = 0; i < s.length(); i++) {
for (int j = i + 1; j < s.length(); j++) {
if (s[i] == s[j]) {
len--;
break;
}
}
}
if (len % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char ch[100];
int i, n, s = 0, j;
scanf("%s", ch);
n = strlen(ch);
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (ch[j] == ch[i]) {
s += 1;
break;
}
}
}
if (((n - s) % 2) == 0)
printf("CHAT WITH HER!");
else
printf("IGNORE HIM!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
vector<char> v;
copy(s.begin(), s.end(), back_inserter(v));
sort(v.begin(), v.end());
int count = distance(v.begin(), unique(v.begin(), v.end()));
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool b[26];
int main() {
string s;
cin >> s;
for (long long int i = 0; i < int(s.length()); ++i) {
b[s[i] - 'a'] = true;
}
int cn = 0;
for (long long int i = 0; i < int(26); ++i) {
if (b[i]) ++cn;
}
cout << ((cn & 1) ? "IGNORE HIM!" : "CHAT WITH HER!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> tree;
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
tree.insert(str[i]);
}
int length_tree = tree.size();
if (length_tree % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int w = 26;
int count = 0;
char a[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
string b;
cin >> b;
for (char c : b) {
for (int m = 0; m < w; m++) {
if (c == a[m]) {
a[m] = '1';
count++;
}
}
}
if (count % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
string str;
int count = 0;
for (int i = 0; (c = getchar()) != '\n'; i++) {
if (str.find(c) == std::string::npos) count++;
str.push_back(c);
}
if (count % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char a[1100], i;
int b, check = 0, s = 0, j;
scanf("%s", a);
b = strlen(a);
for (i = 'a'; i <= 'z'; i++) {
check = 0;
for (j = 0; j < b; j++) {
if (i == a[j]) {
check = 1;
}
}
if (check == 1) {
s = s + 1;
}
}
if (s % 2 == 0) {
printf("CHAT WITH HER!\n");
} else {
printf("IGNORE HIM!\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10010];
int a[27];
int main() {
while (~scanf("%s", s)) {
memset(a, true, sizeof(a));
int cnt = 0;
int len = strlen(s);
for (int i = 0; s[i]; i++) {
if (a[s[i] - 97]) {
a[s[i] - 97] = false;
}
}
for (int i = 0; i < 27; i++) {
if (!a[i]) cnt++;
}
if (cnt % 2 != 0)
printf("IGNORE HIM!\n");
else
printf("CHAT WITH HER!\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> d;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
d.insert(s[i]);
}
if (d.size() % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else
cout << "IGNORE HIM!" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> ns;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) ns.insert(s[i]);
cout << (ns.size() & 1 ? "IGNORE HIM!" : "CHAT WITH HER!");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 0; i < s.size(); i++) {
bool flag = true;
for (int j = 0; j < i; j++) {
if (s[i] == s[j]) {
flag = false;
break;
}
}
if (flag) count++;
}
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int arr[150] = {0}, counter = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (arr[int(s[i])] == 0) {
arr[int(s[i])]++;
counter++;
}
}
if (counter % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int res = 0, ans = 0;
string s, q;
bool tr = false;
cin >> s;
long long int n = s.length();
q += s[0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < q.length(); j++) {
if (s[i] != q[j]) {
res++;
}
}
if (res == q.length()) {
q += s[i];
}
res = 0;
}
long long int qwerty = q.length();
if (qwerty % 2 == 0) {
cout << "CHAT WITH HER!";
} else
cout << "IGNORE HIM!";
return 0;
system("pause");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char name[100];
int i, len, count;
cin >> name;
bool ch[26];
count = 0;
memset(ch, 0, 26);
len = strlen(name);
for (i = 0; i < len; i++) {
if (ch[name[i] - 'a']) continue;
ch[name[i] - 'a'] = true;
count++;
}
if (count % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else
cout << "IGNORE HIM!" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string in;
cin >> in;
int flag = 0;
for (int j = 0; j < 26; j++) {
for (int i = 0; i < in.size(); i++) {
if (in[i] == ('a' + j)) {
flag++;
break;
}
}
}
if (flag % 2 == 0) {
cout << "CHAT WITH HER!" << endl;
} else {
cout << "IGNORE HIM!" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> st;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
st.insert(s[i]);
}
if (st.size() % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool a[257];
int ans = 0;
char s;
int main() {
while (cin >> s) {
if (s != ' ' && s != '\n') a[s] = 1;
}
for (int i = 0; i < 257; i++)
if (a[i] == 1) ans++;
if (ans % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int arr[26] = {0};
int count = 0;
for (int i = 0; i < s.length(); i++) {
if (arr[s[i] - 'a'] == 0) {
count++;
arr[s[i] - 'a'] = 1;
}
}
if ((count % 2))
cout << "IGNORE HIM!"
<< "\n";
else
cout << "CHAT WITH HER!"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char name[101];
int i, j, count = 0;
cin >> name;
for (i = 0; name[i] != '\0'; i++) {
if (name[i] != '1') {
for (j = i + 1; name[j] != '\0'; j++)
if (name[j] == name[i]) name[j] = '1';
}
}
for (i = 0; name[i] != '\0'; i++)
if (name[i] != '1') count++;
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a;
a.resize(28);
int n, sum = 0;
string qwc;
cin >> qwc;
for (int i = 0; i < qwc.size(); i++) {
a[qwc[i] - 97]++;
}
for (int i = 0; i < a.size(); i++) {
if (a[i] > 0) {
sum++;
}
}
cout << (sum % 2 == 0 ? "CHAT WITH HER!" : "IGNORE HIM!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> m;
string s;
cin >> s;
int count = 0, len = s.length();
for (int i = 0; i < len; i++) {
if (m[s[i]] == 0) {
count++;
m[s[i]]++;
}
}
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int size = n.size();
int count = size;
for (int i = 0; i < size; i++) {
if (n[i] != -1) {
for (int j = i + 1; j < size; j++) {
if (n[i] == n[j]) {
n[j] = -1;
count--;
}
}
}
}
if (count % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
}
|
#include <bits/stdc++.h>
using namespace std;
char a[100];
set<char> used;
int main() {
cin >> a;
for (int i = 0; a[i] != 0; i++) used.insert(a[i]);
cout << (used.size() % 2 ? "IGNORE HIM!" : "CHAT WITH HER!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int count = 0;
cin >> str;
for (int i = 0; i < str.length(); i++)
for (int y = i + 1; y < str.length(); y++) {
if (str[i] == str[y]) {
str[y] = '1';
}
}
for (int z = 0; z < str.length(); z++)
if (str[z] != '1') count++;
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void tool();
void solve() {
string name;
cin >> name;
int fre[26] = {0}, dist = 0;
for (char ch : name) {
fre[ch - 'a']++;
if (fre[ch - 'a'] == 1) dist++;
}
if (dist & 1)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
}
int32_t main() {
tool();
int t;
t = 1;
while (t--) solve();
return 0;
}
void tool() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
set<char> s1;
cin >> s;
for (int i = 0; i < s.size(); i++) s1.insert(s[i]);
if (s1.size() % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[1110];
int i, j, k;
int has[30];
memset(has, 0, sizeof(has));
scanf("%s", str);
int sum = 0;
for (i = 0; str[i] != '\0'; i++) {
int temp = str[i] - 'a';
if (has[temp] == 0) {
has[temp]++;
sum++;
}
}
if (sum % 2 == 1)
printf("IGNORE HIM!\n");
else
printf("CHAT WITH HER!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int repeated = 0, ans = 0;
cin >> str;
sort(str.begin(), str.end());
for (int i = 0; i < str.length() - 1; ++i) {
if (str[i] == str[i + 1]) repeated++;
}
ans += str.length() - repeated;
if (ans % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
char s[10000];
int scnt[100000], cnt = 0;
int main() {
memset(scnt, 0, sizeof(scnt));
scanf("%s", s);
for (int i = 0; i < strlen(s); i++) scnt[s[i]]++;
for (int i = 'a'; i <= 'z'; i++)
if (scnt[i]) cnt++;
if (cnt % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, l, a = 1;
cin >> s;
l = s.length();
for (i = 1; i < l; i++) {
for (int j = 0; j < i; j++) {
if (s[i] == s[j]) {
break;
}
if (j == (i - 1) && s[i] != s[j]) {
a++;
}
}
}
if (a % 2 == 0) {
cout << "CHAT WITH HER!" << endl;
} else {
cout << "IGNORE HIM!" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, j, x, count = 0;
char a[105];
scanf("%s", a);
x = strlen(a);
for (i = 0; i < x; i++) {
for (j = 0; j < x; j++) {
if (a[j] != '#') {
if (i != j && a[i] == a[j]) {
a[i] = '#';
}
}
}
}
for (i = 0; i < x; i++) {
if (a[i] != '#') {
count++;
}
}
if (count % 2 == 0) {
printf("CHAT WITH HER!");
} else {
printf("IGNORE HIM!");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int getInt() {
int x;
scanf("%d", &x);
return x;
}
long long getLongLong() {
long long x;
scanf("%I64d", &x);
return x;
}
double getDouble() {
double x;
scanf("%lf", &x);
return x;
}
char getChar() {
char x;
scanf("%c", &x);
return x;
}
template <typename t>
t abs(t a) {
if (a >= 0) return a;
return -a;
}
int main() {
char s[1000];
gets(s);
set<char> st;
for (int i = 0; s[i]; i++) st.insert(s[i]);
if (st.size() & 1)
cout << "IGNORE HIM!\n";
else
cout << "CHAT WITH HER!\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
char alphabet[26] = {};
cin >> s;
for (int i = 0; i < s.length(); ++i) {
char temp = s[i];
s[i] = tolower(temp);
alphabet[s[i] - 'a'] = s[i];
}
int cnt = 0;
for (int j = 0; j < 26; ++j) {
if (alphabet[j] != NULL) cnt++;
}
cout << (cnt % 2 == 0 ? "CHAT WITH HER!" : "IGNORE HIM!");
}
|
#include <bits/stdc++.h>
int main() {
char w[101];
scanf("%s", w);
int i, r, count, d, k;
count = 0;
d = strlen(w);
for (r = 1; r < d; r++) {
for (i = 0; i < r; i++) {
if (w[i] == w[r]) {
count += 1;
break;
}
}
}
k = d - count;
if (k % 2 == 0) {
printf("CHAT WITH HER!\n");
} else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
bool x;
int cnt = 1;
cin >> s;
for (int i = 1; i < s.length(); i++) {
x = true;
for (int v = i - 1; v >= 0; v--) {
if (s[i] == s[v]) {
x = false;
break;
}
}
if (x) cnt++;
}
if (cnt % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
void solve(char *str) {
char letters[101] = {0};
int i = 0;
for (char *ptr = str; *ptr; ++ptr) {
if (!strchr(letters, *ptr)) letters[i++] = *ptr;
}
letters[i] = '\0';
int letters_len = strlen(letters);
if (letters_len & 1)
puts("IGNORE HIM!");
else
puts("CHAT WITH HER!");
}
int main(void) {
char input[101];
scanf("%100s", input);
solve(input);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int counts[26] = {0};
int i, j;
for (i = 0; i < s.size(); i++) {
counts[s[i] - 'a']++;
}
int count = 0;
for (i = 0; i < 26; i++) {
if (counts[i] != 0) count++;
}
count % 2 == 0 ? cout << "CHAT WITH HER!" : cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[26], c = 0;
memset(arr, 0, sizeof(arr));
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if (arr[str[i] - 97] == 0) {
arr[str[i] - 97] = 1;
c++;
}
}
cout << ((c % 2 == 0) ? "CHAT WITH HER!" : "IGNORE HIM!") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
set<char> st;
for (const char ch : s) {
st.insert(ch);
}
cout << (st.size() % 2 == 0 ? "CHAT WITH HER!" : "IGNORE HIM!") << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int counter = 0;
cin >> s;
sort(s.begin(), s.end());
for (int i = 0; i < s.length(); i++) {
if (s[i] != s[i + 1])
counter++;
else
continue;
}
if (counter % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
char a[101];
std::cin >> a;
n = strlen(a);
int count = 0;
int c;
for (int i = 97; i < 123; ++i) {
c = 0;
for (int j = 0; j < n; ++j)
if (a[j] == char(i)) c++;
if (c) count++;
}
if (count % 2)
std::cout << "IGNORE HIM!";
else
std::cout << "CHAT WITH HER!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c = 0, f = 0, b;
string a;
cin >> a;
b = a.size();
for (int i = 0; i < b - 1; ++i) {
for (int j = i + 1; j < b; ++j) {
if (a.at(i) == a.at(j)) {
f = 1;
break;
}
}
if (f == 1) {
c = c + 1;
f = 0;
}
}
c = b - c;
if (c % 2 == 0) cout << "CHAT WITH HER!";
if (c % 2 != 0) cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c = 1, d = 1;
string s;
cin >> s;
for (int i = 1; i < s.size(); i++) {
for (int j = 0; j < i; j++) {
if (s[j] == s[i]) {
d = 0;
break;
} else
d = 1;
}
if (d == 1) c++;
}
if (c % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char arr[200];
char arr1[27] = "abcdefghijklmnopqrstuvwxyz";
scanf("%s", &arr);
int cont = 0;
for (int i = 0; i < strlen(arr1); i++) {
for (int j = 0; j < strlen(arr); j++) {
if (arr1[i] == arr[j]) {
cont++;
break;
} else {
}
}
}
if (cont % 2 == 0) {
printf("CHAT WITH HER!");
} else {
printf("IGNORE HIM!");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int countt = 0;
cin >> s;
int len = s.length();
int arr[26] = {0};
for (int i = 0; i < len; i++) {
arr[s[i] - 97]++;
}
for (int i = 0; i < 26; i++) {
if (arr[i] >= 1) countt++;
}
if (countt % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
}
|
#include <bits/stdc++.h>
int main() {
char s1[101];
scanf("%s", s1);
int len, i, a[27] = {0}, count = 0;
len = strlen(s1);
for (i = 0; i < len; i++) {
a[s1[i] - 97]++;
}
for (i = 0; i < 27; i++) {
if (a[i] == 1)
count++;
else if (a[i] > 1)
count++;
}
if (count % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> c(s.begin(), s.end());
int count = 0;
for (int i = 0; i < c.size(); i++) count++;
if (count % 2)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int b[123] = {0};
for (int i = 0; i < a.size(); i++) b[a[i]] = 1;
int s = 0;
for (int i = 97; i <= 122; i++)
if (b[i] == 1) s++;
if (s % 2 == 0)
cout << "CHAT WITH HER!\n";
else
cout << "IGNORE HIM!\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> s;
char a[150];
cin >> a;
int len = strlen(a);
for (int i = 0; i < len; i++) {
s.insert(a[i]);
}
int length = s.size();
if (length % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else
cout << "IGNORE HIM!" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
const int NMAX = 200010;
int main() {
string s;
cin >> s;
set<char> c;
for (int i = 0; i < s.size(); ++i) c.insert(s[i]);
cout << ((int)c.size() % 2 == 1 ? "IGNORE HIM!" : "CHAT WITH HER!");
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, a[26], len, j, count = 1, k = 0, flag = 0;
char s[101];
scanf("%s", s);
len = strlen(s);
for (i = 0; i < len; i++) {
count = 1;
flag = 0;
for (j = i + 1; j < len; j++) {
if (s[i] == '0') {
count = 0;
break;
}
if (s[i] == s[j] && s[j] != '0') {
count++;
s[j] = '0';
}
flag = 1;
}
if ((count >= 1 && flag == 1) || (flag == 0 && s[i] != '0')) {
a[k] = count;
k++;
}
}
if (k % 2 == 0) {
printf("CHAT WITH HER!");
} else {
printf("IGNORE HIM!");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "";
cin >> s;
int a[26] = {0};
int b = 0;
for (int i = 0; i < s.length(); i++) {
if (a[int(s[i]) - 97] == 0) {
b++;
}
a[int(s[i]) - 97]++;
}
if (b % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.