text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int arr[4010];
int rib(int ribbonsize, int a, int b, int c) {
if (ribbonsize < 0) {
return -100000;
}
if (ribbonsize == 0) {
return 0;
}
if (arr[ribbonsize] != -1) {
return arr[ribbonsize];
} else {
return arr[ribbonsize] = max(rib(ribbonsize - a, a, b, c),
max(rib(ribbonsize - b, a, b, c),
rib(ribbonsize - c, a, b, c))) +
1;
}
}
int main() {
memset(arr, -1, sizeof(arr));
int ribbonsize, a, b, c;
cin >> ribbonsize >> a >> b >> c;
cout << rib(ribbonsize, a, b, c) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m;
const int N = 1e6;
long long int dp[N];
long long int vis[N];
vector<long long int> cost;
int main() {
long long int n, a, b, c;
cin >> n >> a >> b >> c;
dp[a] = dp[b] = dp[c] = 1;
for (int i = 1; i <= n; i++) {
if (i - a >= 0 && dp[i - a] != 0) dp[i] = max(dp[i], dp[i - a] + 1);
if (i - b >= 0 && dp[i - b] != 0) dp[i] = max(dp[i], dp[i - b] + 1);
if (i - c >= 0 && dp[i - c] != 0) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, j, n, a, b, c, m, s = 1;
cin >> n >> a >> b >> c;
for (i = 0; i <= 4000; i++)
for (j = 0; j <= 4000; j++) {
m = n - a * i - b * j;
if (m >= 0 && m % c == 0) s = std::max(s, i + j + m / c);
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[8005], b, c, a, n, g, i;
int main() {
cin >> n >> a >> b >> c;
l[a] = l[b] = l[c] = 1;
for (i = 1; i < n; i++) {
if (l[i] > 0) {
if (l[i] + 1 > l[a + i]) l[i + a] = l[i] + 1;
if (l[i] + 1 > l[b + i]) l[i + b] = l[i] + 1;
if (l[i] + 1 > l[c + i]) l[i + c] = l[i] + 1;
}
}
cout << l[n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> dp(n + 1, -INF);
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
if (i - a >= 0 && dp[i] < dp[i - a] + 1) {
dp[i] = dp[i - a] + 1;
}
if (i - b >= 0 && dp[i] < dp[i - b] + 1) {
dp[i] = dp[i - b] + 1;
}
if (i - c >= 0 && dp[i] < dp[i - c] + 1) {
dp[i] = dp[i - c] + 1;
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4005;
int len[3], ans;
int vst[MAX];
int dp[MAX];
int dfs(int step, int remain) {
if (dp[remain]) return dp[remain];
if (remain == 0) {
if (step > ans) ans = step;
return ans;
}
int Max = 0, temp = 0;
for (int i = 0; i < 3; i++) {
if (remain - len[i] >= 0) {
temp = dfs(step + 1, remain - len[i]);
if (temp > Max) Max = temp;
}
}
dp[remain] = Max + 1;
return dp[remain];
}
int main(void) {
int n;
scanf("%d %d %d %d", &n, &len[0], &len[1], &len[2]);
ans = 0;
sort(len, len + 3);
dfs(0, n);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T t) {
cout << t << endl;
}
long long n = 0, t = 0;
long long small = -1e18, big = 1e18;
const long long mod = 1e9 + 7;
map<long long, long long> occ;
map<pair<long long, long long>, long long> occP;
void print2dVec(vector<vector<long long>> v) {
for (int i = 0; i < v.size(); ++i) {
cout << i << " : ";
for (int j = 0; j < v[i].size(); ++j) {
cout << v[i][j] << " ";
}
print("");
}
}
void printSet(set<int> s) {
for (auto itr = s.begin(); itr != s.end(); ++itr) {
cout << *itr << " ";
}
}
long long factorial(int n) {
long long ans = 1;
for (int i = 1; i <= n; ++i) {
ans *= i;
}
return ans;
}
long long findGCD(long long a, long long b) {
long long ans = 1;
for (int i = 1; i <= min(a, b); ++i) {
if (a % i == 0 && b % i == 0) {
ans = i;
}
}
return ans;
}
long long findLCM(long long a, long long b) {
for (long long i = min(a, b); i <= a * b; ++i) {
if (i % a == 0 && i % b == 0) {
return i;
}
}
return -1;
}
bool isPrime(int num) {
if (num <= 1) return false;
if (num <= 3) return true;
int range = sqrt(num);
if (num % 2 == 0 || num % 3 == 0) return false;
for (int i = 5; i <= range; i += 6)
if (num % i == 0 || num % (i + 2) == 0) return false;
return true;
}
vector<long long> primeFactors(long long x) {
vector<long long> fac;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
while (x % i == 0) {
fac.push_back(i);
x /= i;
}
}
}
return fac;
}
bool sortVec(const vector<long long>& v1, const vector<long long>& v2) {
return v1[0] < v2[0];
}
bool check(long long val) { return false; }
long long binsearch(long long low, long long high) {
while (low < high) {
long long mid = (low + high) / 2;
if (check(mid)) {
high = mid;
} else {
low = mid + 1;
}
}
return low;
}
unordered_map<long long, long long> d;
long long rib(long long n, long long a, long long b, long long c) {
if (n == 0) return 0;
if (n < 0) return small;
if (d.count(n))
return d[n];
else {
d[n] = 1 + max(rib(n - a, a, b, c),
max(rib(n - b, a, b, c), rib(n - c, a, b, c)));
return d[n];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
long long n, a, b, c;
cin >> n >> a >> b >> c;
cout << rib(n, a, b, c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> dp(n + 1);
dp[0] = 0;
int arr[3] = {a, b, c};
for (int i = 1; i < n; i++) {
dp[i] = INT_MIN;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
if ((i - arr[j]) >= 0) {
dp[i] = max(dp[i - arr[j]] + 1, dp[i]);
}
}
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e4 + 1;
void display(vector<long long> dp, long long n) {
long long i;
for (i = 1; i <= n; i++) {
cout << dp[i] << " ";
}
cout << endl;
}
void solve() {
long long n, a, b, c;
long long x, y, z;
long long m, i;
vector<long long> dp(maxn, 0);
cin >> n >> a >> b >> c;
dp[0] = 0;
for (i = 1; i <= n; i++) {
x = y = z = -1;
if (i >= a) {
x = dp[i - a];
}
if (i >= b) {
y = dp[i - b];
}
if (i >= c) {
z = dp[i - c];
}
if (x == -1 && y == -1 && z == -1) {
dp[i] = -1;
} else {
dp[i] = max(x, max(y, z)) + 1;
}
}
cout << dp[n] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t, a, b, c, ans;
void solve() {
ans = -1;
for (int i = (0), _b = (n); i <= _b; i++) {
for (int j = (0), _b = (n); j <= _b; j++) {
int tmp = n - i - j;
if (tmp < 0) continue;
if (i % a == 0 && j % b == 0 && tmp % c == 0) {
int tmp2 = i / a + j / b + tmp / c;
ans = max(ans, tmp2);
}
}
}
cout << ans << endl;
}
int main() {
scanf("%d", &n);
scanf("%d %d %d", &a, &b, &c);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int ans[100005];
void solve() {
int a, b, c;
cin >> n >> a >> b >> c;
ans[a] = ans[b] = ans[c] = 1;
for (int i = 0; i <= n; ++i) {
ans[i + a] = max(ans[i + a], (ans[i] != 0) * (1 + ans[i]));
ans[i + b] = max(ans[i + b], (ans[i] != 0) * (1 + ans[i]));
ans[i + c] = max(ans[i + c], (ans[i] != 0) * (1 + ans[i]));
}
cout << ans[n];
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, x, y, mini, maxi;
cin >> n >> a >> b >> c;
mini = min(a, min(b, c));
if (n % mini == 0) {
cout << n / mini << endl;
return 0;
}
maxi = n / mini;
int p = 0;
for (x = maxi; x >= 0; x--) {
if ((a * x) > n) continue;
for (y = 0; y <= maxi; y++) {
if ((a * x) + (b * y) > n) continue;
int z = abs((n - ((a * x) + (b * y))) / c);
if ((a * x) + (b * y) + (c * z) == n) {
p = max(p, x + y + z);
}
}
}
cout << p << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[3];
int main() {
scanf("%d%d%d%d", &n, &a[0], &a[1], &a[2]);
sort(a, a + 3);
int i, j;
i = 0;
j = 0;
int ans = 0;
for (i = 0; i * a[2] <= n; i++)
for (j = 0; (i * a[2] + j * a[1]) <= n; j++) {
int k = n - i * a[2] - j * a[1];
if (k >= 0 && k % a[0] == 0) ans = max(ans, i + j + k / a[0]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int d[4002];
int f(int u) {
if (u == 0) return 0;
if (u < 0) return -1;
if (d[u] > -2) return d[u];
int k = f(u - a) + 1;
int p = f(u - a);
if (p == -1) k = -1;
int l = f(u - b) + 1;
p = f(u - b);
if (p == -1) l = -1;
int h = f(u - c) + 1;
p = f(u - c);
if (p == -1) h = -1;
if (h > k) swap(k, h);
if (l > k) swap(k, l);
return d[u] = k;
}
int main() {
while (cin >> n >> a >> b >> c) {
memset(d, -2, sizeof d);
if (a < b) swap(a, b);
if (b < c) swap(b, c);
int cnt = f(n);
cout << cnt << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100001;
const int INF = 999999;
int MAX = -INF;
int N, A, B, C;
int dp[MAXN];
int main() {
N = read(), A = read(), B = read(), C = read();
for (int i = min(A, min(B, C)); i <= N; i++) {
if (i - A >= 0)
if (dp[i - A] || i - A == 0) dp[i] = max(dp[i], dp[i - A] + 1);
if (i - B >= 0)
if (dp[i - B] || i - B == 0) dp[i] = max(dp[i], dp[i - B] + 1);
if (i - C >= 0)
if (dp[i - C] || i - C == 0) dp[i] = max(dp[i], dp[i - C] + 1);
}
printf("%d\n", dp[N]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, A, B, C;
cin >> N >> A >> B >> C;
vector<int> M(N + 1, -100000);
M[0] = 0;
for (int i = 1; i <= N; ++i)
M[i] =
max({i >= A ? M[i - A] + 1 : -100000, i >= B ? M[i - B] + 1 : -100000,
i >= C ? M[i - C] + 1 : -100000});
cout << M[N] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, max = 0, max2 = 0, n2;
cin >> n;
n2 = n;
int arr[3];
for (int i = 0; i < 3; i++) cin >> arr[i];
sort(arr, arr + 3);
a = arr[0];
b = arr[1];
c = arr[2];
bool u = true;
int i = 1, y = 1;
int x = n;
int f;
while (u) {
f = (n / a);
max += f;
n -= (a * f);
if (n == 0) break;
max = 0;
n = x;
if (n - (i * b) < 0) {
n -= (y * c);
max += y;
i = 0;
y++;
}
n = x;
max = 0;
if (y > 1) {
max += (y - 1);
n -= ((y - 1) * c);
}
n -= (i * b);
max += i;
i++;
}
i = 1;
y = 1;
x = n2;
while (u) {
f = (n2 / a);
max2 += f;
n2 -= (a * f);
if (n2 == 0) break;
max2 = 0;
n2 = x;
if (n2 - (i * c) < 0) {
n2 -= (y * b);
max2 += y;
i = 0;
y++;
}
n2 = x;
max2 = 0;
if (y > 1) {
max2 += (y - 1);
n2 -= ((y - 1) * b);
}
n2 -= (i * c);
max2 += i;
i++;
}
if (max > max2)
cout << max << endl;
else
cout << max2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
vector<int> a(3);
cin >> n >> a[0] >> a[1] >> a[2];
vector<int> dp(n + 1, -1);
for (int i : a)
if (i <= n) dp[i] = 1;
for (int i = 0; i <= n; i++) {
for (int j : a)
if (i - j > 0 && dp[i - j] != -1) dp[i] = max(dp[i], dp[i - j] + 1);
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
int a, b, c, n, dp[4001];
cin >> n >> a >> b >> c;
for (int i = 1; i <= n; i++) {
dp[i] = 0;
if (a == i || b == i || c == i) dp[i] = 1;
for (int j = 1; j <= i / 2; j++) {
if (dp[j] != 0 && dp[i - j] != 0) dp[i] = max(dp[i], (dp[j] + dp[i - j]));
}
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int arr[3];
arr[0] = a;
arr[1] = b;
arr[2] = c;
sort(arr, arr + 3);
int max = -1;
for (int i = 0; i <= n / arr[0]; ++i) {
for (int j = 0; j <= n / arr[1]; ++j) {
if ((n - arr[0] * i - arr[1] * j) % arr[2] == 0 &&
(n - arr[0] * i - arr[1] * j) >= 0) {
if (max < (i + j + (n - arr[0] * i - arr[1] * j) / arr[2]))
max = (i + j + (n - arr[0] * i - arr[1] * j) / arr[2]);
}
}
}
cout << max;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d = 1, e = 2, f = 3, i, j, h = 0, k = 0, l = 0, m = 0, o = 0,
p = 0, q = 0, r = 0, s = 0, t = 0, u = 0, v = 0, w = 0, x = 0,
y = 0;
cin >> n >> a >> b >> c;
if (a <= b && a <= c)
j = a;
else if (b <= a && b <= c)
j = b;
else if (c <= a && c <= b)
j = c;
if (n % j != 0) {
if (n == a | n == b | n == c) {
if (a == b + c | b == c + a | c == a + b) {
} else {
o++;
s = d;
}
}
if (n == a + b | n == b + c | n == a + c) {
o++;
s = e;
}
if (n == a + b + c) {
o++;
s = f;
}
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if ((i * a) + (j * b) == n) {
p = i + j;
if (p > k) k = p;
}
if ((i * b) + (j * c) == n) {
q = i + j;
if (q > l) l = q;
}
if ((i * c) + (j * a) == n) {
r = i + j;
if (r > m) m = r;
}
if ((i * a) + (j * b) + c == n) {
t = i + j + 1;
if (t > u) u = t;
}
if ((i * b) + (j * c) + a == n) {
v = i + j + 1;
if (v > w) w = v;
}
if ((i * c) + (j * a) + b == n) {
x = i + j + 1;
if (x > y) y = x;
}
}
}
if (k > s | l > s | m > s | u > s | w > s | y > s) {
if (k >= l && k >= m && k >= u && k >= w && k >= y)
cout << k;
else if (l >= k && l >= m && l >= u && l >= w && l >= y)
cout << l;
else if (m >= k && m >= l && m >= u && m >= w && m >= y)
cout << m;
else if (u >= k && u >= l && u >= w && u >= y)
cout << u;
else if (w >= k && w >= l && w >= u && w >= y)
cout << w;
else if (y >= k && y >= l && y >= u && y >= w)
cout << y;
} else {
cout << s;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
long long int dp[8010];
long long int solve(int idx) {
long long int& ans = dp[idx];
if (ans != -1) return ans;
if (idx > n) return ans = -INT_MAX / 2;
if (idx == n) return ans = 0;
return ans = 1 + max({solve(idx + a), solve(idx + b), solve(idx + c)});
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
memset(dp, -1, sizeof dp);
cin >> n >> a >> b >> c;
cout << solve(0) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
void input() { cin >> n >> a >> b >> c; }
int mx = -1;
int k = 0;
void solve() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
k = n - (i * a + j * b);
if (k % c == 0 && k >= 0) {
mx = max(mx, i + j + (k / c));
}
}
}
}
void output() { cout << mx; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
solve();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int dp[4001] = {INT_MIN};
int abc[3];
for (int i = 0; i < 4001; i++) {
dp[i] = INT_MIN;
}
for (int i = 0; i < 3; i++) {
cin >> abc[i];
}
sort(abc, abc + 3);
dp[0] = 0;
dp[abc[0]] = 1;
dp[abc[1]] = 1;
dp[abc[2]] = 1;
cout << endl;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
if (abc[j] > i) break;
dp[i] = max(dp[i], dp[i - abc[j]] + 1);
}
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[10000100];
long long a, b, c;
long long rec(long long n) {
if (n < 0) return -1e18;
if (n == 0) return 0;
if (dp[n] != -1) return dp[n];
long long res1 = rec(n - a) + 1;
long long res2 = rec(n - b) + 1;
long long res3 = rec(n - c) + 1;
long long k = max(res1, res2);
return dp[n] = max(k, res3);
}
int main() {
memset(dp, -1, sizeof(dp));
long long n;
cin >> n;
cin >> a >> b >> c;
cout << rec(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans, a, b, c;
int main() {
cin >> n >> a >> b >> c;
for (int i = 0; i * a <= n; ++i) {
for (int j = 0; i * a + j * b <= n; ++j) {
int k = (n - i * a - j * b) / c;
if (i * a + j * b + k * c == n) ans = max(ans, i + j + k);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int ans = 0;
int main() {
cin >> n >> a >> b >> c;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if ((n - (i * a) - (j * b)) % c != 0) {
continue;
}
if (n - (i * a) - (j * b) < 0) {
continue;
}
int k = (n - (i * a) - (j * b)) / c;
if (i + j + k > ans) ans = i + j + k;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1e9 + 5;
long long int mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, a, b, c;
cin >> n >> a >> b >> c;
vector<long long int> dp(n + 1, -INF);
dp[0] = 0;
for (long long int i = 1; i <= n; i++) {
dp[i] =
max({dp[i], (i >= a ? dp[i - a] + 1 : -INF),
(i >= b ? dp[i - b] + 1 : -INF), (i >= c ? dp[i - c] + 1 : -INF)});
}
cout << dp[n] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, a, b, c, i, x = 0, y = 0, z = 0;
cin >> n >> a >> b >> c;
vector<long long> dp(n + 1, 0);
dp[0] = 1;
for (i = 1; i <= n; i++) {
x = 0;
y = 0;
z = 0;
if (a <= i) x = (dp[i - a] > 0) ? dp[i - a] + 1 : 0;
if (b <= i) y = (dp[i - b] > 0) ? dp[i - b] + 1 : 0;
if (c <= i) z = (dp[i - c] > 0) ? dp[i - c] + 1 : 0;
dp[i] = max(x, max(y, z));
}
cout << dp[n] - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, answer, e;
int main() {
cin >> a >> b >> c >> d;
for (int i = 0; i <= a; i++)
for (int j = 0; j <= a; j++) {
e = a - i * b - j * c;
if (e >= 0 && e % d == 0 && answer < i + j + e / d)
answer = i + j + e / d;
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
void Solution() {
int t;
t = 1;
while (t--) {
int n, a, b, c;
cin >> n >> a >> b >> c;
int dp[100005] = {0};
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
if (n - a >= 0) dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (dp[i + a] || dp[i + b] || dp[i + c]) {
dp[i] = max(max(dp[i + a], dp[i + b]), dp[i + c]) + 1;
}
}
cout << dp[0] - 1 << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Solution();
}
|
#include <bits/stdc++.h>
using namespace std;
long long getCount(long long n, long long a, long long b, long long c,
long long mem[]) {
mem[0] = 0;
for (long long i = a; i <= n; i += a) {
mem[i] = i / a;
}
for (long long i = b; i <= n; i += 1) {
if (mem[i] == -1) {
if (mem[i - b] != -1) {
mem[i] = mem[i - b] + 1;
}
}
}
for (long long i = c; i <= n; i += 1) {
if (mem[i - c] != -1) {
if (mem[i] != -1)
mem[i] = max(mem[i], mem[i - c] + 1);
else
mem[i] = mem[i - c] + 1;
}
}
return mem[n];
}
int main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long* mem = new long long[n + 1];
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
std::fill(mem, mem + n + 1, -1);
cout << getCount(n, a, b, c, mem) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[4003];
int func(int n) {
if (n < 0) return -500000000;
if (n == 0) return 0;
if (~dp[n]) return dp[n];
int p = 1 + func(n - a);
int q = 1 + func(n - b);
int r = 1 + func(n - c);
int x = max(p, q);
return dp[n] = max(x, r);
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d %d %d %d", &n, &a, &b, &c);
cout << func(n) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[10000];
int f(int s) {
if (s < 0) {
return -1000000000;
}
if (s == 0) return 1;
if (dp[s]) return dp[s];
dp[s] = max(f(s - a), max(f(s - b), f(s - c))) + 1;
return dp[s];
}
int main() {
cin >> n >> a >> b >> c;
cout << f(n) - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101000;
int n, a, b, c;
int main() {
cin.sync_with_stdio(false);
cin >> n >> a >> b >> c;
int res = 0;
for (int i = 0; i < (n / a) + 1; i++) {
for (int j = 0; j < (n / b) + 1; j++) {
int l = n - i * a - j * b;
if (l >= 0 && l % c == 0) {
res = max(res, i + j + l / c);
}
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, ans = 0, x;
cin >> n >> a >> b >> c;
if (a > b) swap(a, b);
if (a > c) swap(a, c);
for (int i = 0; i <= 4000; i++)
for (int j = 0; j <= 4000; j++)
ans = ((((n - i * b - j * c) % a == 0) && (n - i * b - j * c) >= 0)
? max(ans, i + j + (n - i * b - j * c) / a)
: ans);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int recc(int n, int dp[]) {
if (n == 0) return 0;
if (n < 0) return -1;
if (dp[n] != 0) return dp[n];
int c1 = recc(n - a, dp), c2 = recc(n - b, dp), c3 = recc(n - c, dp);
int ans = max({c1, c2, c3});
if (ans == -1) return dp[n] = -1;
return dp[n] = 1 + ans;
}
int main() {
int n;
cin >> n;
cin >> a >> b >> c;
int dp[n + 1];
memset(dp, 0, sizeof(dp));
cout << recc(n, dp) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
int p = 0, ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n / a; i++) {
for (int j = 0; j <= n - a * i; j++) {
if (n - a * i - b * j >= 0 && (n - a * i - b * j) % c == 0) {
p = i + j + (n - a * i - b * j) / c;
}
ans = max(ans, p);
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> dp(n + 1, INT_MIN);
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
int ai = i - a;
int bi = i - b;
int ci = i - c;
if (ai >= 0 && dp[ai] != INT_MIN) {
dp[i] = max(dp[i], dp[ai] + 1);
}
if (bi >= 0 && dp[bi] != INT_MIN) {
dp[i] = max(dp[i], dp[bi] + 1);
}
if (ci >= 0 && dp[ci] != INT_MIN) {
dp[i] = max(dp[i], dp[ci] + 1);
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int func(int n) {
if (n < 0) {
return 1;
} else {
return n;
}
}
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
if (a == 1 || b == 1 || c == 1) {
cout << n << "\n";
} else {
vector<int> v(n + 1);
int d = min(a, min(b, c));
for (int i = 0; i < d; i++) {
if (i == 0) {
v[i] = 0;
} else {
v[i] = -100000;
}
}
for (int i = 1; i <= n; i++) {
v[i] = 1 + max(v[func(i - a)], max(v[func(i - b)], v[func(i - c)]));
}
cout << v[n] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4001];
int max(int a, int b, int c) {
if (a >= b && a >= c)
return a;
else if (b >= a && b >= c)
return b;
else
return c;
}
int ribbons(int n, int a, int b, int c, int minl) {
if (n == 0)
return 0;
else if (n < minl)
return -10000000;
else if (dp[n] != -1)
return dp[n];
return dp[n] = 1 + max(ribbons(n - a, a, b, c, minl),
ribbons(n - b, a, b, c, minl),
ribbons(n - c, a, b, c, minl));
}
int main(int argc, char const *argv[]) {
int n, a, b, c;
cin >> n >> a >> b >> c;
int minl = min(a, min(b, c));
memset(dp, -1, sizeof(dp));
cout << ribbons(n, a, b, c, minl);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n;
cin >> n >> a >> b >> c;
int i, p = 0, x, y, z;
i = min(a, min(b, c));
i = n / i;
for (x = i; x >= 0; x--) {
for (y = 0; y <= i; y++) {
z = abs((n - (a * x + b * y)) / c);
if ((a * x + b * y + c * z) == n) {
p = max(p, x + y + z);
}
}
}
cout << p << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool files = false;
bool testing = true;
template <class T>
void prAr(T ar[], int len) {
cout << "Printing array:"
<< "\n";
for (int i = 0; i < len; i++) {
cout << *(ar + i) << "\n";
}
}
template <class T>
void prV(vector<T> v) {
cout << "Printing vector:"
<< "\n";
for (T i : v) {
cout << i << "\n";
}
}
template <class T>
void pr2V(vector<vector<T>> v) {
cout << "Printing vector:"
<< "\n";
for (vector<T> x : v) {
for (int i = 0; i < x.size(); i++) {
cout << x[i] << " ";
}
cout << "\n";
}
}
template <class T>
vector<T> duplicates(vector<T> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
template <class T>
bool isIn(T x, vector<T> v) {
return find(v.begin(), v.end(), x) != v.end();
}
template <class T>
long long binSearch(vector<T> v, T x) {
long long min = 0, max = (long long)(v.size() - 1);
if (min == max) {
if (x == v[min]) {
return min;
} else {
return -1;
}
}
long long mid = (min + max) / 2;
T test;
while (max - min != 1) {
test = v[mid];
if (test > x) {
max = mid;
} else if (test < x) {
min = mid;
} else {
return mid;
}
mid = (min + max) / 2;
}
if (v[max] == x) {
return max;
}
if (v[min] == x) {
return min;
}
return -1;
}
long long toBin(long long n) {
long long ans = 0, r;
long long i = 0;
while (n != 0) {
r = n % 2;
ans += (long long)r * pow(10, i);
n = (n - r) / 2;
i++;
}
return ans;
}
int binDigs(long long n) {
if (n == 1) {
return 1;
}
int ans = 0;
long long temp = 1;
while (temp <= n) {
temp *= 2;
ans++;
}
return ans;
}
int fromBin(int n) {
int ans = 0, r;
int i = 0;
while (n != 0) {
r = n % 2;
ans += (int)r * pow(2, i);
n = (n - r) / 10;
i++;
}
return ans;
}
int ones(long long n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
if (n & (1 << i)) {
ans++;
}
}
return ans;
}
int lZeros(int n) {
if (n == 0) {
return 32;
}
int ans = 0;
int i = 31;
while (!(n & (1 << i))) {
ans++;
i--;
}
return ans;
}
int tZeros(int n) {
if (n == 0) {
return 32;
}
int ans = 0;
int i = 0;
while (!(n & (1 << i))) {
ans++;
i++;
}
return ans;
}
vector<int> digits(long long n) {
vector<int> ans;
if (n == 0) {
ans = {0};
return ans;
}
int len = (int)log10(n) + 1;
int r;
for (int i = 0; i < len; i++) {
r = n % 10;
ans.push_back(r);
n = (n - r) / 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long fromDigits(vector<int> v) {
reverse(v.begin(), v.end());
long long ans = 0;
for (int i = 0; i < v.size(); i++) {
ans += v[i] * (long long)pow(10, i);
}
return ans;
}
string rnConvertSingle(int n, int e) {
string ans;
char one[4] = {'I', 'X', 'C', 'M'};
char five[3] = {'V', 'L', 'D'};
switch (n) {
case 1:
ans.push_back(one[e]);
break;
case 2:
ans.push_back(one[e]);
ans.push_back(one[e]);
break;
case 3:
ans.push_back(one[e]);
ans.push_back(one[e]);
ans.push_back(one[e]);
break;
case 4:
ans.push_back(one[e]);
ans.push_back(five[e]);
break;
case 5:
ans.push_back(five[e]);
break;
case 6:
ans.push_back(five[e]);
ans.push_back(one[e]);
break;
case 7:
ans.push_back(five[e]);
ans.push_back(one[e]);
ans.push_back(one[e]);
break;
case 8:
ans.push_back(five[e]);
ans.push_back(one[e]);
ans.push_back(one[e]);
ans.push_back(one[e]);
break;
case 9:
ans.push_back(one[e]);
ans.push_back(one[e + 1]);
break;
case 0:
ans = "";
break;
default:
break;
}
return ans;
}
string convert(int n) {
vector<int> digs = digits(n);
string ans;
for (int i = 0; i < digs.size(); i++) {
string s = rnConvertSingle(digs[i], (int)digs.size() - 1 - i);
ans.append(s);
}
return ans;
}
bool isPalindrome(string s) {
string c = s;
reverse(s.begin(), s.end());
return c == s;
}
int square(int n) { return (int)pow(n, 2); }
bool between(int x, int a, int b) { return x >= a && x <= b; }
vector<long long> primes(long long n) {
vector<long long> ans;
vector<bool> composite;
composite.resize(n + 1);
composite[0] = composite[1] = true;
long long lim = sqrt(n) + 1;
long long mult;
long long i = 2;
while (i < lim) {
if (!composite[i]) {
mult = n / i;
for (int j = 2; j < mult + 1; j++) {
composite[j * i] = true;
}
}
i++;
}
for (int i = 2; i < n + 1; i++) {
if (!composite[i]) {
ans.push_back(i);
}
}
return ans;
}
bool isPrime(long long n) {
long long lim = (long long)sqrt(n) + 1;
for (int i = 2; i < lim; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
vector<vector<long long>> factor(long long n) {
vector<vector<long long>> ans;
if (n == 1) {
return {{1, 1}};
}
vector<long long> ps = primes(n);
for (int i = 0; i < ps.size(); i++) {
if (n % ps[i] == 0) {
long long count = 0;
while (n % ps[i] == 0) {
n = n / (ps[i]);
count++;
}
ans.push_back({ps[i], count});
}
}
return ans;
}
int gcd(int a, int b) {
int big = max(a, b);
int small = min(a, b);
while (big * small != 0) {
big -= (big / small) * small;
swap(big, small);
}
return big;
}
vector<vector<int>> perms(int n) {
vector<vector<int>> ans;
vector<int> start;
for (int j = 0; j < n; j++) {
start.push_back(j);
}
do {
ans.push_back(start);
} while (next_permutation(start.begin(), start.end()));
return ans;
}
vector<vector<int>> combos(int n) {
vector<vector<int>> ans;
vector<int> subset;
for (int i = 0; i < (int)pow(2, n); i++) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
subset.push_back(j);
}
}
ans.push_back(subset);
subset.clear();
}
return ans;
}
long long fact(int n) {
long long ar[n + 1];
ar[0] = 1;
for (int i = 0; i < n; i++) {
ar[i + 1] = (i + 1) * ar[i];
}
return ar[n];
}
long long nCr(int n, int r) { return fact(n) / (fact(n - r) * fact(r)); }
long long bnCr(int n, int r) {
long long val[n + 1][n + 1];
for (int i = 0; i < n + 1; i++) {
val[i][0] = 1;
val[i][i] = 1;
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < i; j++) {
val[i][j] = val[i - 1][j - 1] + val[i - 1][j];
}
}
return val[n][r];
}
long long nPr(int n, int r) { return fact(n) / fact(n - r); }
ifstream in;
ofstream out;
int n;
int a, b, c;
int mx = 0;
int remain;
void solve() {
int aMax = n / a;
int bMax = n / b;
for (int i = 0; i < aMax + 1; i++) {
for (int j = 0; j < bMax + 1; j++) {
remain = n - i * a - j * b;
if (remain >= 0 && remain % c == 0) {
if (i + j + (n - i * a - j * b) / c > mx) {
mx = i + j + (n - i * a - j * b) / c;
}
}
}
}
}
void read() {
cin >> n >> a >> b >> c;
solve();
cout << mx << "\n";
}
int main() {
if (files) {
if (testing) {
in.open("input");
out.open("output");
} else {
in.open("nocows.in");
out.open("nocows.out");
}
}
read();
out.close();
in.close();
return 0;
}
|
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int dp[4003];
int main() {
int a[3];
int n, i, j, temp;
while (scanf("%d%d%d%d", &n, &a[0], &a[1], &a[2]) != EOF) {
memset(dp, 0, sizeof(dp));
for (i = 0; i < 2; i++)
for (j = i + 1; j < 3; j++) {
if (a[i] > a[j]) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
for (i = 0; i < 3; i++) {
for (j = a[i]; j <= n; j++) {
if (j % a[i] == 0) {
dp[j] = max(dp[j - a[i]] + 1, dp[j]);
} else if ((j - a[i]) >= a[0] && dp[j - a[i]] != 0) {
dp[j] = max(dp[j - a[i]] + 1, dp[j]);
}
}
}
printf("%d\n", dp[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum_count(int n, int m1, int m2, int m3) {
int arr[4005];
arr[0] = 0;
for (int x = 1; x <= n; x++) {
if (x - m1 < 0) {
arr[x] = INT_MIN;
} else if (x - m1 == 0) {
arr[x] = 1;
} else {
int p1 = arr[x - m1] + arr[m1];
if (p1 < 0 && x - m2 < 0) {
arr[x] = INT_MIN;
} else if (p1 < 0 && x - m2 == 0) {
arr[x] = 1;
} else {
if (x - m2 < 0) {
arr[x] = p1;
continue;
}
int p2 = arr[x - m2] + arr[m2];
if (p2 < 0 && x - m3 == 0 && p1 < 0) {
arr[x] = 1;
} else if (p2 < 0 && x - m3 < 0 && p1 < 0) {
arr[x] = INT_MIN;
} else {
if (x - m3 < 0 && x - m2 >= 0) {
arr[x] = max(p1, p2);
} else {
int p3 = arr[x - m3] + arr[m3];
arr[x] = max(max(p1, p2), p3);
}
}
}
}
}
return arr[n];
}
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> p;
p.push_back(a);
p.push_back(b);
p.push_back(c);
sort(p.begin(), p.end());
int m1 = p[0];
int m2 = p[1];
int m3 = p[2];
int ans = sum_count(n, m1, m2, m3);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 100000 + 100;
const int inf = 0x7fffffff;
int n, a, b, c;
int f[N];
int main() {
scanf("%d%d%d%d", &n, &a, &b, &c);
for (int i = 1; i <= n; i++) f[i] = -inf;
f[0] = 0;
for (int i = min(a, min(b, c)); i <= n; i++) {
if (i >= a && f[i - a] != inf) f[i] = max(f[i], f[i - a] + 1);
if (i >= b && f[i - b] != inf) f[i] = max(f[i], f[i - b] + 1);
if (i >= c && f[i - c] != inf) f[i] = max(f[i], f[i - c] + 1);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4010];
int a, b, c, res, n;
int solve(int n) {
if (n <= 0) return 0;
if (dp[n] != -1) return dp[n];
int res = -1e+14;
if (n >= a) res = max(res, solve(n - a) + 1);
if (n >= b) res = max(res, solve(n - b) + 1);
if (n >= c) res = max(res, solve(n - c) + 1);
return dp[n] = res;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> a >> b >> c;
cout << solve(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i * a <= n; i++) {
for (int j = 0; i * a + j * b <= n; j++) {
int left = n - i * a - j * b;
if (left % c == 0) ans = max(ans, i + j + left / c);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, k, mx = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if ((n - (i * a + j * b)) >= 0 && (n - (i * a + j * b)) % c == 0)
mx = max(mx, i + j + ((n - (i * a + j * b)) / c));
}
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c;
cin >> a >> b >> c;
int max = -1;
int count = 0;
int len = 0;
int mini = min(a, min(b, c));
if (n % mini == 0) {
cout << n / mini;
return 0;
}
if (a == 2 && c == 3) {
cout << n / 2;
return 0;
}
for (int i = 0; i <= (n / a); i++) {
for (int j = 0; j <= (n / b); j++) {
for (int k = 0; k <= (n / c); k++) {
len = i * a + j * b + c * k;
count = i + j + k;
if (len == n) {
if (count > max) max = count;
}
}
}
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4040, inF = 1e9;
int n, a, b, c, dp[N];
int main() {
cin >> n >> a >> b >> c;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = -inF;
if (i >= a) dp[i] = max(dp[i], dp[i - a] + 1);
if (i >= b) dp[i] = max(dp[i], dp[i - b] + 1);
if (i >= c) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int get_max_pieces(int ribbon_size, int*& candidate_sizes);
int main() {
int ribbon_size;
cin >> ribbon_size;
int* candidate_sizes = new int[3];
for (int c = 0; c < 3; c++) {
cin >> candidate_sizes[c];
}
int max_pieces = get_max_pieces(ribbon_size, candidate_sizes);
cout << max_pieces << endl;
}
int get_max_pieces(int ribbon_size, int*& candidate_sizes) {
int* max_pieces = new int[ribbon_size + 1]();
for (int c = 0; c < 3; c++) {
if (candidate_sizes[c] <= ribbon_size) {
max_pieces[candidate_sizes[c]] = 1;
}
}
for (int state = 0; state < ribbon_size; state++) {
if (max_pieces[state]) {
for (int c = 0; c < 3; c++) {
int next = state + candidate_sizes[c];
if (next <= ribbon_size) {
max_pieces[next] = max(max_pieces[next], max_pieces[state] + 1);
}
}
}
}
return max_pieces[ribbon_size];
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4001];
int n, a, b, c;
int memo(int leng);
int main() {
memset(dp, -1, sizeof dp);
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> a >> b >> c;
cout << memo(0);
}
int memo(int leng) {
if (leng > n) return -1e9;
if (leng == n) return 0;
if (dp[leng] != -1) return dp[leng];
return dp[leng] = max(max(1 + memo(leng + a), 1 + memo(leng + b)),
1 + memo(leng + c));
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, ans[4010];
scanf("%d %d %d %d", &n, &a, &b, &c);
memset(ans, -1, sizeof(ans));
ans[0] = 0;
for (int i = 0; i <= n; i++) {
if (i >= a && ans[i - a] != -1) ans[i] = ans[i - a] + 1;
if (i >= b && ans[i - b] != -1) ans[i] = max(ans[i], ans[i - b] + 1);
if (i >= c && ans[i - c] != -1) ans[i] = max(ans[i], ans[i - c] + 1);
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, n, max_cnt = 0;
int main() {
cin >> n >> a >> b >> c;
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= n; j++)
if ((n - (a * i) - (b * j)) >= 0 && (n - (a * i) - (b * j)) % c == 0)
max_cnt = max(max_cnt, i + j + (n - (a * i) - (b * j)) / c);
cout << max_cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 605, X = 90005, M = 200005;
int n, m, p, S, T, nA, nB, cnt, du[N], le[X], ri[X], ans[X];
int tot, lnk[N], son[M], w[M], v[M], nxt[M];
int q[N], dst[N], pre[N];
bool bo[N], vis[N];
int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
void Ifmin(int &x, int y) {
if (y < x) x = y;
}
void add(int x, int y, int z1, int z2) {
tot++;
son[tot] = y;
w[tot] = z1;
v[tot] = z2;
nxt[tot] = lnk[x];
lnk[x] = tot;
tot++;
son[tot] = x;
w[tot] = 0;
v[tot] = -z2;
nxt[tot] = lnk[y];
lnk[y] = tot;
}
bool spfa() {
for (int i = (1); i <= (n); i++) bo[i] = vis[i] = 0, dst[i] = 1e9;
int hed = 0, tal = 1;
dst[q[1] = S] = 0;
bo[S] = vis[S] = 1;
while (hed != tal) {
int x = q[hed = (hed + 1) % N];
vis[x] = 0;
for (int j = lnk[x]; j; j = nxt[j])
if (w[j] > 0 && dst[x] + v[j] < dst[son[j]]) {
dst[son[j]] = dst[x] + v[j];
bo[son[j]] = 1;
pre[son[j]] = j;
if (!vis[son[j]]) vis[q[tal = (tal + 1) % N] = son[j]] = 1;
}
}
return bo[T];
}
void getflow() {
while (spfa()) {
int mn = 1e9;
for (int x = T; x != S; x = son[pre[x] ^ 1]) Ifmin(mn, w[pre[x]]);
for (int x = T; x != S; x = son[pre[x] ^ 1])
w[pre[x]] -= mn, w[pre[x] ^ 1] += mn;
}
}
int main() {
nA = read(), nB = read(), m = read(), p = read();
for (int i = (1); i <= (m); i++) le[i] = read(), ri[i] = read();
for (int i = (1); i <= (m); i++) du[le[i]]++, du[nA + ri[i]]++;
for (int i = (1); i <= (nA + nB); i++)
if (du[i] % p) cnt++;
printf("%d\n", cnt);
for (n = nA + nB, S = ++n, T = ++n; p; p--) {
tot = 1;
memset(lnk, 0, sizeof(lnk));
for (int i = (1); i <= (m); i++)
if (!ans[i]) add(le[i], nA + ri[i], 1, 0);
for (int i = (1); i <= (nA); i++) {
add(S, i, du[i] / p, 0);
if (du[i] % p) add(S, i, 1, 1);
}
for (int i = (nA + 1); i <= (nA + nB); i++) {
add(i, T, du[i] / p, 0);
if (du[i] % p) add(i, T, 1, 1);
}
getflow();
int _ = 0;
for (int i = (1); i <= (m); i++)
if (!ans[i]) {
_ += 2;
if (!w[_]) ans[i] = p, du[le[i]]--, du[nA + ri[i]]--;
}
}
for (int i = (1); i <= (m); i++) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace flow {
const int SOURCE = 0;
const int SINK = 1;
map<int, int> M[405];
map<int, int> M2[405];
vector<int> st;
bool bio[405][3];
bool dfs(int id, int lim) {
if (bio[id][lim]++) return false;
st.push_back(id);
if (id == SINK) return true;
for (auto t : M[id])
if (t.second && dfs(t.first, lim)) return true;
if (lim)
for (auto t : M2[id])
if (t.second && dfs(t.first, lim - 1)) return true;
st.pop_back();
return false;
}
bool dfsControl(int id) {
for (int i = (int)(0); i < (int)(3); ++i) {
memset(bio, 0, sizeof bio);
st.clear();
if (dfs(id, i)) return true;
}
return false;
}
int run() {
int r = 0;
while (dfsControl(SOURCE)) {
++r;
for (int i = (int)(0); i < (int)(st.size() - 1); ++i) {
if (M[st[i]][st[i + 1]])
--M[st[i]][st[i + 1]], ++M[st[i + 1]][st[i]];
else
--M2[st[i]][st[i + 1]], ++M2[st[i + 1]][st[i]];
}
}
return r;
}
void reset() {
for (int i = (int)(0); i < (int)(405); ++i) M[i].clear();
for (int i = (int)(0); i < (int)(405); ++i) M2[i].clear();
}
void edge(int first, int second, int c) { M[first][second] += c; }
void edge2(int first, int second, int c) { M2[first][second] += c; }
} // namespace flow
using namespace flow;
int n, m, k, t;
pair<int, int> E[5005];
int cnt[5005];
int output[5005];
int main() {
cin >> n >> m >> k >> t;
for (int i = (int)(0); i < (int)(k); ++i)
cin >> E[i].first >> E[i].second, --E[i].first, --E[i].second;
for (int i = (int)(0); i < (int)(k); ++i)
++cnt[E[i].first], ++cnt[n + E[i].second];
int R = 0;
int check = 0;
int tt = t;
for (int i = (int)(0); i < (int)(n + m); ++i) R += !!(cnt[i] % t);
for (int blatruc = (int)(0); blatruc < (int)(t); ++blatruc) {
reset();
for (int i = (int)(0); i < (int)(k); ++i)
if (!output[i]) edge(2 + E[i].first, 2 + n + E[i].second, 1);
for (int i = (int)(0); i < (int)(n); ++i) edge(SOURCE, 2 + i, cnt[i] / tt);
for (int i = (int)(0); i < (int)(m); ++i)
edge(2 + n + i, SINK, cnt[n + i] / tt);
for (int i = (int)(0); i < (int)(n); ++i)
edge2(SOURCE, 2 + i, (cnt[i] + tt - 1) / tt - cnt[i] / tt);
for (int i = (int)(0); i < (int)(m); ++i)
edge2(2 + n + i, SINK, (cnt[n + i] + tt - 1) / tt - cnt[n + i] / tt);
check += run();
for (int i = (int)(0); i < (int)(k); ++i)
if (!output[i]) {
if (M[2 + n + E[i].second][2 + E[i].first]) {
output[i] = blatruc + 1;
++M[2 + n + E[i].second][2 + E[i].first];
--cnt[E[i].first], --cnt[n + E[i].second];
continue;
}
if (M2[2 + n + E[i].second][2 + E[i].first]) {
output[i] = blatruc + 1;
++M2[2 + n + E[i].second][2 + E[i].first];
--cnt[E[i].first], --cnt[n + E[i].second];
continue;
}
}
--tt;
}
assert(check == k);
cout << R << endl;
for (int i = (int)(0); i < (int)(k); ++i) cout << output[i] << " ";
cout << endl;
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], qr[50000];
void bd(int x, int y, int c) {
qd[++ed] = y, qn[ed] = l[x], l[x] = ed, qc[ed] = qr[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 << 28);
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);
int Low = 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);
Low += lo;
}
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);
Low += lo;
}
bd(S, SS, (1 << 30));
bd(SS, S, 0);
bd(TT, T, (1 << 30));
bd(T, TT, 0);
int F = MaxFlow();
for (int j = (2); j <= (ed); j++) qc[j] = qr[j];
for (int j = (l[S]); j; j = qn[j])
if (qd[j] == SS) qc[j] = 0;
for (int j = (l[TT]); j; j = qn[j])
if (qd[j] == T) qc[j] = 0;
bd(TT, SS, F - Low), 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;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
return;
}
template <typename T1, typename T2>
inline void scf(T1 &x, T2 &y) {
scf(x);
scf(y);
}
template <typename T1, typename T2, typename T3>
inline void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
inline void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
scf(w);
}
template <typename T>
inline bool chkmin(T &x, const T &y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmax(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
const int maxn = 210;
const int maxk = 5010;
const int maxv = maxn * 2;
const int maxe = (maxn * 4 + maxk) * 2;
struct edge {
int to, cap, cst, next;
edge() {}
edge(int N, int T, int C, int CS) : next(N), to(T), cap(C), cst(CS) {}
} e[maxe];
int n, m, k, tot, ans, S, T, e_n;
int x[maxk], y[maxk], col[maxk], cntx[maxn], cnty[maxn];
bool in[maxv];
int dst[maxv], q[maxv * maxv], prevv[maxv], preve[maxv], head[maxv];
void add_edge(int u, int v, int cap, int cst) {
e[e_n] = edge(head[u], v, cap, cst);
head[u] = e_n++;
e[e_n] = edge(head[v], u, 0, -cst);
head[v] = e_n++;
return;
}
bool spfa() {
memset(dst, 0x3f, sizeof dst);
memset(in, 0, sizeof in);
int fnt, rar;
fnt = rar = 0;
q[rar++] = S;
dst[S] = 0;
in[S] = 1;
while (fnt != rar) {
int u = q[fnt++];
in[u] = 0;
for (int i = head[u]; ~i; i = e[i].next)
if (e[i].cap && dst[e[i].to] > dst[u] + e[i].cst) {
dst[e[i].to] = dst[u] + e[i].cst;
prevv[e[i].to] = u;
preve[e[i].to] = i;
if (!in[e[i].to]) q[rar++] = e[i].to, in[e[i].to] = 1;
}
}
return dst[T] < 100000;
}
void mcmf() {
while (spfa()) {
int mn = 0x3f;
for (int u = T; u; u = prevv[u]) chkmin(mn, e[preve[u]].cap);
for (int u = T; u; u = prevv[u])
e[preve[u]].cap -= mn, e[preve[u] ^ 1].cap += mn;
}
return;
}
int main() {
scf(n, m, k, tot);
for (int i = (1); i <= (k); ++i) scf(x[i], y[i]), ++cntx[x[i]], ++cnty[y[i]];
for (int i = (1); i <= (n); ++i) ans += !!(cntx[i] % tot);
for (int i = (1); i <= (m); ++i) ans += !!(cnty[i] % tot);
for (int C = (tot); C >= (1); --C) {
memset(head, -1, sizeof head);
S = 0;
T = n + m + 1;
e_n = 0;
for (int i = (1); i <= (k); ++i)
if (!col[i]) add_edge(x[i], y[i] + n, 1, 0);
for (int i = (1); i <= (n); ++i) {
add_edge(S, i, cntx[i] / C, 0);
if (cntx[i] % C) add_edge(S, i, 1, 1);
}
for (int i = (1); i <= (m); ++i) {
add_edge(i + n, T, cnty[i] / C, 0);
if (cnty[i] % C) add_edge(i + n, T, 1, 1);
}
mcmf();
e_n = 0;
for (int i = (1); i <= (k); ++i)
if (!col[i]) {
if (!e[e_n].cap) col[i] = C, --cntx[x[i]], --cnty[y[i]];
e_n += 2;
}
}
printf("%d\n", ans);
for (int i = (1); i <= (k); ++i) printf("%d%c", col[i], i == k ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 405;
const int maxm = 5005;
const int INF = 1000000000;
const int mod = 1000000;
struct EDGE {
int cap, cost, v, next;
} edge[mod];
int head[maxn], E, q[mod];
bool used[maxn];
int pre[maxn], cur[maxn], dis[maxn];
void add_edge(int s, int t, int cap, int cost) {
edge[E].cap = cap;
edge[E].cost = cost;
edge[E].next = head[s];
edge[E].v = t;
head[s] = E++;
edge[E].cap = 0;
edge[E].cost = -cost;
edge[E].next = head[t];
edge[E].v = s;
head[t] = E++;
}
int min(int a, int b) { return (a == -1 || b < a) ? b : a; }
int SPFA(int s, int t, int n) {
int f = -1, r = 0;
int i, v;
q[r] = s;
for (i = 0; i < n; i++) dis[i] = INF;
dis[s] = 0;
pre[s] = s;
cur[s] = -1;
memset(used, false, sizeof(bool) * n);
used[s] = true;
while (f != r) {
f++;
if (f >= mod) f -= mod;
s = q[f];
used[s] = false;
for (i = head[s]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (edge[i].cap > 0 && dis[s] + edge[i].cost < dis[v]) {
dis[v] = dis[s] + edge[i].cost;
pre[v] = s;
cur[v] = i;
if (!used[v]) {
used[v] = true;
r++;
if (r >= mod) r -= mod;
q[r] = v;
}
}
}
}
return dis[t];
}
int MinCost(int s, int t, int n) {
int ans = 0;
int u, v, cap;
int cost;
while (1) {
cost = SPFA(s, t, n);
if (cost == INF) break;
u = v = t;
cap = -1;
for (u = t; u != s; u = pre[u]) {
cap = min(cap, edge[cur[u]].cap);
}
ans += cost * cap;
u = v = t;
for (u = t; u != s; u = pre[u]) {
edge[cur[u]].cap -= cap;
edge[cur[u] ^ 1].cap += cap;
}
}
return ans;
}
int dx[maxn];
int dy[maxn];
int c[maxm];
int x[maxm];
int y[maxm];
int main() {
int n, m, g, k, z;
int i, j;
int s, t;
while (scanf("%d%d%d%d", &n, &m, &k, &g) != -1) {
memset(dx, 0, sizeof(int) * n);
memset(dy, 0, sizeof(int) * m);
for (i = 0; i < k; i++) {
scanf("%d%d", &x[i], &y[i]);
dx[--x[i]]++;
dy[--y[i]]++;
}
int ans = 0;
for (i = 0; i < n; i++) ans += dx[i] % g != 0;
for (i = 0; i < m; i++) ans += dy[i] % g != 0;
printf("%d\n", ans);
memset(c, -1, sizeof(int) * k);
s = n + m;
t = s + 1;
for (; g >= 1; g--) {
E = 0;
memset(head, -1, sizeof(int) * (t + 1));
for (i = 0; i < k; i++)
if (c[i] == -1) add_edge(x[i], y[i] + n, 1, 0);
for (i = 0; i < n; i++) {
add_edge(s, i, dx[i] / g, 0);
if (dx[i] % g) add_edge(s, i, 1, 1);
}
for (i = 0; i < m; i++) {
add_edge(i + n, t, dy[i] / g, 0);
if (dy[i] % g) add_edge(i + n, t, 1, 1);
}
MinCost(s, t, t + 1);
for (i = 0, z = 0; i < k; i++)
if (c[i] == -1) {
if (edge[z].cap == 0) {
c[i] = g;
dx[x[i]]--;
dy[y[i]]--;
}
z += 2;
}
}
for (i = 0; i < k; i++) {
if (i) printf(" ");
printf("%d", c[i]);
}
puts("");
}
return 0;
}
|
#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;
const int N = 405, K = 5005, inf = 1e9 + 7;
int n, m, k, t, S, T, tot;
int de[N], hd[N], dis[N], fl[N], pre[N];
bool vis[N];
struct point {
int x, y, c;
} a[K];
struct edge {
int n, v, flow, w;
} e[K << 2];
void add(int u, int v, int flow, int w) {
e[++tot] = (edge){hd[u], v, flow, w}, hd[u] = tot;
e[++tot] = (edge){hd[v], u, 0, -w}, hd[v] = tot;
}
bool SPFA() {
memset(fl + 1, 0, T << 2), memset(dis + 1, 63, T << 2), memset(vis + 1, 0, T);
queue<int> Q;
Q.push(S);
fl[S] = inf, dis[S] = 0;
int u;
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int i = hd[u]; i; i = e[i].n)
if (e[i].flow && dis[e[i].v] > dis[u] + e[i].w) {
dis[e[i].v] = dis[u] + e[i].w;
pre[e[i].v] = i, fl[e[i].v] = min(fl[u], e[i].flow);
if (!vis[e[i].v]) Q.push(e[i].v), vis[e[i].v] = 1;
}
vis[u] = 0;
}
if (!fl[T]) return 0;
u = T;
int nf = fl[T];
while (u ^ S) {
e[pre[u]].flow -= nf, e[pre[u] ^ 1].flow += nf;
u = e[pre[u] ^ 1].v;
}
return 1;
}
void solve(int nt) {
tot = 1;
memset(hd + 1, 0, T << 2);
for (int i = 1; i <= k; ++i)
if (!a[i].c) add(a[i].x, n + a[i].y, 1, 0);
for (int i = 1; i <= n; ++i)
if (de[i]) add(S, i, de[i] / nt, 0), (de[i] % nt && (add(S, i, 1, 1), 1));
for (int i = 1; i <= m; ++i)
if (de[i + n])
add(i + n, T, de[i + n] / nt, 0),
(de[i + n] % nt && (add(i + n, T, 1, 1), 1));
while (SPFA())
;
int now = 2;
for (int i = 1; i <= k; ++i)
if (!a[i].c)
(!e[now].flow && (a[i].c = nt, de[a[i].x]--, de[a[i].y + n]--, 1)),
now += 2;
}
int main() {
cin >> n >> m >> k >> t;
for (int i = 1; i <= k; ++i)
cin >> a[i].x >> a[i].y, de[a[i].x]++, de[a[i].y + n]++;
S = n + m + 1, T = n + m + 2;
int ans = 0;
for (int i = 1; i <= n + m; ++i) ans += (de[i] % t != 0);
cout << ans << '\n';
for (int i = t; i >= 1; --i) solve(i);
for (int i = 1; i <= k; ++i) cout << a[i].c << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 402, maxe = 2 * (5000 + 800);
struct Graph {
int head[maxv];
int next[maxe];
int to[maxe];
int cf[maxe];
int w[maxe];
int k;
int n;
Graph(int _n = 0) : n(_n) { clear(); }
void clear() {
memset(head, -1, sizeof(head));
k = 0;
}
void adde(int s, int t, int cc, int ww) {
next[k] = head[s], head[s] = k, to[k] = t, w[k] = ww, cf[k] = cc, k++;
next[k] = head[t], head[t] = k, to[k] = s, w[k] = -ww, cf[k] = 0, k++;
}
int dist[maxv], pr[maxv], maxpush[maxv];
int st[maxv * maxv];
bool used[maxv];
void mincost(int S, int T) {
while (1) {
for (int i = 0; i < n; i++)
dist[i] = ((int)1E9), pr[i] = -1, maxpush[i] = 0, used[i] = 0;
dist[S] = 0, maxpush[S] = ((int)1E9);
st[0] = S;
for (int l = 0, r = 1; l < r; l++) {
int v = st[l];
used[v] = 0;
for (int edge = head[v]; edge != -1; edge = next[edge]) {
int u = to[edge];
if (cf[edge] && dist[u] > dist[v] + w[edge]) {
if (!used[u]) st[r++] = u, used[u] = 1;
dist[u] = dist[v] + w[edge];
pr[u] = edge;
maxpush[u] = min(maxpush[v], cf[edge]);
}
}
}
if (pr[T] == -1) break;
for (int v = T; v != S; v = to[pr[v] ^ 1]) {
cf[pr[v]] -= maxpush[T], cf[pr[v] ^ 1] += maxpush[T];
}
}
}
};
Graph g;
int edges[maxe][2];
int degs[2][maxv];
int ans[maxe];
int main() {
int n, m, k, t;
while (scanf("%d%d%d%d", &n, &m, &k, &t) >= 4) {
memset(degs, 0, sizeof(degs));
for (int i = 0; i < k; i++)
for (int j = 0; j < 2; j++)
scanf("%d", &edges[i][j]), degs[j][--edges[i][j]]++;
int res = 0;
for (int i = 0; i < n; i++) res += !!(degs[0][i] % t);
for (int i = 0; i < m; i++) res += !!(degs[1][i] % t);
printf("%d\n", res);
memset(ans, 0, sizeof(ans));
g.n = n + m + 2;
for (int parts = t; parts; parts--) {
g.clear();
for (int i = 0; i < k; i++)
if (!ans[i]) g.adde(edges[i][0], n + edges[i][1], 1, 0);
int S = n + m, T = S + 1;
for (int i = 0; i < n; i++) {
g.adde(S, i, degs[0][i] / parts, 0);
if (degs[0][i] % parts) g.adde(S, i, 1, 1);
}
for (int i = 0; i < m; i++) {
g.adde(i + n, T, degs[1][i] / parts, 0);
if (degs[1][i] % parts) g.adde(i + n, T, 1, 1);
}
g.mincost(S, T);
for (int i = 0, id = 0; i < k; i++)
if (!ans[i]) {
if (!g.cf[id])
ans[i] = parts, degs[0][edges[i][0]]--, degs[1][edges[i][1]]--;
id += 2;
}
}
for (int i = 0; i < k; i++) printf("%d%c", ans[i], " \n"[i == k - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5002;
namespace EdgeColoring {
int deg[2][N];
pair<int, int> has[2][N][205];
int color[5005];
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] = pair<int, int>(0, 0);
}
}
}
}
void dfs(int x, int p) {
auto e = has[p][x][c[!p]];
if (has[!p][e.first][c[p]].second)
dfs(e.first, !p);
else
has[!p][e.first][c[!p]] = pair<int, int>(0, 0);
has[p][x][c[p]] = e;
has[!p][e.first][c[p]] = pair<int, int>(x, e.second);
color[e.second] = c[p];
}
int solve(vector<pair<int, int>> edges, vector<int> &res) {
int m = edges.size(), ans = 0;
for (int i = 1; i <= m; i++) {
int x[2];
x[0] = edges[i - 1].first;
x[1] = edges[i - 1].second;
for (int d = 0; d < 2; d++) {
deg[d][x[d]]++;
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]] = pair<int, int>(x[!d], i);
color[i] = c[0];
}
res.resize(m);
for (int i = 1; i <= m; i++) {
res[i - 1] = color[i];
color[i] = 0;
}
return ans;
}
}; // namespace EdgeColoring
int deg[N][2], id[N][2], l, r;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, t, k;
cin >> n >> m >> k >> t;
vector<pair<int, int>> edges;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
if (deg[x][0] == 0) id[x][0] = ++l;
if (deg[y][1] == 0) id[y][1] = ++r;
deg[x][0] = (deg[x][0] + 1) % t;
deg[y][1] = (deg[y][1] + 1) % t;
edges.push_back({id[x][0], id[y][1]});
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += !!deg[i][0];
for (int i = 1; i <= m; i++) ans += !!deg[i][1];
cout << ans << '\n';
vector<int> color;
EdgeColoring::solve(edges, color);
for (auto x : color) cout << x << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505, M = 1e5 + 5, inf = 1e9;
char buf[1 << 23], *p1 = buf, *p2 = buf;
int fst[N], cur[N], nxt[M], u[M], v[M], flow[M], tot = 1;
int n, m, k, tp, x[5005], y[5005], del[5005];
int dis[N], que[N], id[N][N], h, t;
int S = N - 2, T = N - 1, ss = N - 3, tt = N - 4, D[N];
int mx[N], mi[N], ans;
int read() {
int res = 0, fl = 0;
char a =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
while (a < '0' || a > '9')
fl |= a == '-',
a = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
while (a >= '0' && a <= '9')
res = res * 10 + a - '0',
a = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
return fl ? -res : res;
}
void add(int lu, int lv, int lf) {
u[++tot] = lu, v[tot] = lv, flow[tot] = lf, nxt[tot] = fst[lu], fst[lu] = tot;
u[++tot] = lv, v[tot] = lu, flow[tot] = 0, nxt[tot] = fst[lv], fst[lv] = tot;
}
bool bfs() {
que[h = t = 1] = S, memset(dis, 0x3f, sizeof(dis)), dis[S] = 0;
while (h <= t)
for (int i = que[h++], j = fst[i]; j; j = nxt[j])
if (flow[j] && dis[v[j]] > dis[i] + 1)
dis[v[j]] = dis[i] + 1, que[++t] = v[j];
return dis[T] < inf;
}
int dfs(int x, int lw) {
if (x == T) return lw;
int res = 0, zl;
for (int &i = cur[x]; i; i = nxt[i])
if (flow[i] && dis[v[i]] == dis[x] + 1 &&
(zl = dfs(v[i], min(lw, flow[i])))) {
res += zl, flow[i ^ 1] += zl, flow[i] -= zl, lw -= zl;
if (!lw) return res;
}
return res;
}
int dinic() {
int res = 0;
while (bfs()) memcpy(cur, fst, sizeof(cur)), res += dfs(S, inf);
return res;
}
int main() {
int i, j, li;
n = read(), m = read(), k = read(), tp = read(), memset(mi, 0x3f, sizeof(mi));
for (i = 1; i <= k; i++) x[i] = read(), y[i] = read(), id[x[i]][y[i]] = i;
for (; tp; tp--) {
int pp = 0, qq = 0;
memset(fst, 0, sizeof(fst)), memset(D, 0, sizeof(D)), tot = 1;
for (i = 1; i <= k; i++)
if (!del[i]) D[x[i]]++, D[y[i] + n]++, add(x[i], y[i] + n, 1);
for (i = 1; i <= n; i++)
(D[i] % tp) && (add(ss, i, 1), 1), pp += D[i] / tp, add(S, i, D[i] / tp);
for (i = n + 1; i <= n + m; i++)
(D[i] % tp) && (add(i, tt, 1), 1), qq += D[i] / tp, add(i, T, D[i] / tp);
add(ss, T, pp), add(S, tt, qq), add(tt, ss, inf), dinic();
for (i = 1; i <= n; mx[i] = max(mx[i], li), mi[i] = min(mi[i], li), i++)
for (li = D[i] / tp, j = fst[i]; j; j = nxt[j])
if (v[j] > n && !flow[j])
del[id[i][v[j] - n]] = tp;
else if (v[j] == ss)
li += flow[j];
for (i = n + 1; i <= n + m;
mx[i] = max(mx[i], li), mi[i] = min(mi[i], li), i++)
for (li = D[i] / tp, j = fst[i]; j; j = nxt[j])
if (v[j] == tt) li += 1 - flow[j];
}
for (i = 1; i <= n + m; i++) ans += mx[i] - mi[i];
cout << ans << '\n';
for (i = 1; i <= k; i++) cout << del[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
inline bool chmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
void GG() {
puts("-1");
exit(0);
}
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int MM = 1e3 + 10;
long long fac[MM], facinv[MM], Inv[MM];
long long Comb(int n, int m) {
return n < 0 or n < m ? 0 : fac[n] * facinv[m] % MOD * facinv[n - m] % MOD;
}
void PRE() {
fac[0] = 1;
for (int i = (1), I = (MM - 1); i <= I; i++) fac[i] = fac[i - 1] * i % MOD;
facinv[MM - 1] = invm(fac[MM - 1]);
for (int i = (MM - 1), I = (1); i >= I; i--)
facinv[i - 1] = facinv[i] * i % MOD;
Inv[1] = 1;
for (int i = (2), I = (MM - 1); i <= I; i++)
Inv[i] = (MOD - MOD / i) * Inv[MOD % i] % MOD;
}
const int N = 1e6 + 10;
int cur[N], deg[N], id;
vector<pair<int, int> > to[N];
int col[N];
void solve(int x, int c1, int c2) {
col[to[x][c1].second] = c2;
swap(to[x][c1], to[x][c2]);
if (to[x][c2].first) solve(to[x][c2].first, c2, c1);
}
void main() {
int n1 = qread(), n2 = qread(), m = qread(), K = qread();
for (int i = (1), I = (m); i <= I; i++) {
int x = qread(), y = n1 + qread();
if (deg[x] % K == 0) to[cur[x] = ++id].resize(K);
deg[x]++;
x = cur[x];
if (deg[y] % K == 0) to[cur[y] = ++id].resize(K);
deg[y]++;
y = cur[y];
int c1;
for (int t = (0), I = (K - 1); t <= I; t++)
if (!to[x][t].first) {
c1 = t;
break;
}
if (to[y][c1].first) {
int c2;
for (int t = (0), I = (K - 1); t <= I; t++)
if (!to[y][t].first) {
c2 = t;
break;
}
solve(y, c1, c2);
}
to[x][c1] = {y, i}, to[y][c1] = {x, i}, col[i] = c1;
}
int ans = 0;
for (int i = (1), I = (n1 + n2); i <= I; i++) ans += (deg[i] % K > 0);
write2(ans);
for (int i = (1), I = (m); i <= I; i++) write1(1 + col[i]);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::PRE();
mine::main();
printf("");
}
|
#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');
}
int deg[11010], to[11010][210], id[11010][210];
int col[5010];
int cur1[210], cur2[210];
int n1, n2, m, k, cnt;
void adjust(int x, int c1, int c2) {
while (x) {
col[id[x][c1]] = c2;
std::swap(to[x][c1], to[x][c2]);
std::swap(id[x][c1], id[x][c2]);
x = to[x][c2];
std::swap(c1, c2);
}
}
int main() {
n1 = read();
n2 = read();
m = read();
k = read();
deg[0] = k;
cnt = 0;
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if (deg[cur1[x]] == k) cur1[x] = ++cnt, deg[cur1[x]] = 0;
if (deg[cur2[y]] == k) cur2[y] = ++cnt, deg[cur2[y]] = 0;
++deg[cur1[x]];
++deg[cur2[y]];
int cx = 0, cy = 0;
for (int j = 1; j <= k; j++)
if (!to[cur1[x]][j]) {
cx = j;
break;
}
if (to[cur2[y]][cx]) {
for (int j = 1; j <= k; j++)
if (!to[cur2[y]][j]) {
cy = j;
break;
}
adjust(cur2[y], cx, cy);
}
to[cur1[x]][cx] = cur2[y];
id[cur1[x]][cx] = i;
to[cur2[y]][cx] = cur1[x];
id[cur2[y]][cx] = i;
col[i] = cx;
}
int ans = 0;
for (int i = 1; i <= cnt; i++)
if (deg[i] < k) ++ans;
writeln(ans);
for (int i = 1; i <= m; i++) writesp(col[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
inline bool chmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
void GG() {
puts("-1");
exit(0);
}
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int MM = 1e3 + 10;
long long fac[MM], facinv[MM], Inv[MM];
long long Comb(int n, int m) {
return n < 0 or n < m ? 0 : fac[n] * facinv[m] % MOD * facinv[n - m] % MOD;
}
void PRE() {
fac[0] = 1;
for (int i = (1), I = (MM - 1); i <= I; i++) fac[i] = fac[i - 1] * i % MOD;
facinv[MM - 1] = invm(fac[MM - 1]);
for (int i = (MM - 1), I = (1); i >= I; i--)
facinv[i - 1] = facinv[i] * i % MOD;
Inv[1] = 1;
for (int i = (2), I = (MM - 1); i <= I; i++)
Inv[i] = (MOD - MOD / i) * Inv[MOD % i] % MOD;
}
const int N = 1e6 + 10;
int cur[N], deg[N], id;
vector<pair<int, int> > to[N];
int col[N];
void solve(int x, int c1, int c2) {
col[to[x][c1].second] = c2;
swap(to[x][c1], to[x][c2]);
if (to[x][c2].first) solve(to[x][c2].first, c2, c1);
}
void main() {
int n1 = qread(), n2 = qread(), m = qread(), K = qread();
for (int i = (1), I = (m); i <= I; i++) {
int x = qread(), y = n1 + qread();
if (deg[x] % K == 0) to[cur[x] = ++id].resize(K);
deg[x]++;
x = cur[x];
if (deg[y] % K == 0) to[cur[y] = ++id].resize(K);
deg[y]++;
y = cur[y];
int c1;
for (int t = (0), I = (K - 1); t <= I; t++)
if (!to[x][t].first) c1 = t;
if (to[y][c1].first) {
int c2;
for (int t = (0), I = (K - 1); t <= I; t++)
if (!to[y][t].first) c2 = t;
solve(y, c1, c2);
}
to[x][c1] = {y, i}, to[y][c1] = {x, i}, col[i] = c1;
}
int ans = 0;
for (int i = (1), I = (n1 + n2); i <= I; i++) ans += (deg[i] % K > 0);
write2(ans);
for (int i = (1), I = (m); i <= I; i++) write1(1 + col[i]);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::PRE();
mine::main();
printf("");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t, x, y;
int h[210 << 1], tot;
int dis[210 << 1], vis[210 << 1], pre[210 << 1], prd[210 << 1],
q[210 * 210 * 4], ql, qr, S, T;
int d[5010][2], dx[210], dy[210], c[5010], ans;
struct edge {
int v, c, w, n;
edge(int y = 0, int z = 0, int d = 0, int t = 0) : v(y), c(z), w(d), n(t) {}
} e[5010 << 2];
void link(int x, int y, int z, int d) {
e[++tot] = edge(y, z, d, h[x]), h[x] = tot;
}
void flink(int x, int y, int w, int z) { link(x, y, w, z), link(y, x, 0, -z); }
bool SPFA() {
for (int i = S; i <= T; i++) dis[i] = (1 << 30);
;
ql = qr = 0;
dis[S] = 0, vis[S] = 1, q[++qr] = S;
for (int o; ql++ < qr;) {
o = q[ql];
for (int x = h[o], y; y = e[x].v, x; x = e[x].n)
if (e[x].c && dis[o] + e[x].w < dis[y]) {
dis[y] = dis[o] + e[x].w, pre[y] = o, prd[y] = x;
if (!vis[y]) vis[y] = 1, q[++qr] = y;
}
vis[o] = 0;
}
return dis[T] < (1 << 30);
;
}
void flow() {
while (SPFA()) {
int nf(1 << 30);
for (int o = T; o != S; o = pre[o]) nf = min(e[prd[o]].c, nf);
for (int o = T; o != S; o = pre[o])
e[prd[o]].c -= nf, e[prd[o] ^ 1].c += nf;
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &k, &t);
for (int i = 1; i <= k; i++)
scanf("%d %d", &x, &y), dx[x]++, dy[y]++, d[i][0] = x, d[i][1] = y;
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);
S = 0, T = n + m + 1;
for (int TT = t; TT >= 1; TT--) {
tot = 1, memset(h, 0, sizeof(h));
for (int i = 1; i <= k; i++) {
x = d[i][0], y = d[i][1];
if (!c[i]) flink(x, y + n, 1, 0);
}
for (int i = 1; i <= n; i++) {
flink(S, i, dx[i] / TT, 0);
if (dx[i] % TT) flink(S, i, 1, 1);
}
for (int i = 1; i <= m; i++) {
flink(i + n, T, dy[i] / TT, 0);
if (dy[i] % TT) flink(i + n, T, 1, 1);
}
flow();
for (int i = 2, j = 1; j <= k; j++)
if (!c[j]) {
if (!e[i].c) c[j] = TT, dx[d[j][0]]--, dy[d[j][1]]--;
i += 2;
}
}
for (int i = 1; i <= n; i++)
if (dx[i]) printf("-1-1-1\n");
for (int i = 1; i <= n; i++)
if (dy[i]) printf("-1-1-1\n");
for (int i = 1; i <= k; i++) printf("%d ", c[i]);
return 0;
}
|
#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;
using ll = long long;
const int maxn = 5005, maxm = 5005;
struct edge_color {
int deg[2][maxn];
pair<int, int> 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] = pair<int, int>(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]] = pair<int, int>(0, 0);
has[p][x][c[p]] = i;
has[!p][i.first][c[p]] = pair<int, int>(x, i.second);
color[i.second] = c[p];
}
int solve(vector<pair<int, int>> v, vector<int> &cv) {
int m = 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]] = pair<int, int>(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 N, M, T, K;
int deg[2][maxn], idx[2][maxn];
vector<pair<int, int>> edges;
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> K >> T;
int n, m;
n = m = 0;
while (K--) {
int u, v;
cin >> u >> v;
if (deg[0][u] == 0) idx[0][u] = ++n;
if (deg[1][v] == 0) idx[1][v] = ++m;
++deg[0][u];
++deg[1][v];
if (deg[0][u] == T) deg[0][u] = 0;
if (deg[1][v] == T) deg[1][v] = 0;
edges.emplace_back(idx[0][u], idx[1][v]);
}
int res = 0;
for (int i = 1; i <= N; ++i) {
res += (deg[0][i] > 0);
}
for (int i = 1; i <= M; ++i) {
res += (deg[1][i] > 0);
}
cout << res << '\n';
vector<int> col;
EC.solve(edges, col);
for (int i : col) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int fir[1000100], nex[1000100], to[1000100], e[1000100], S, T, d[1000100], na,
nb, k, m, top = 1, h[1000100], vh[1000100], las[1000100], out[1000100];
int sap(int x, int f) {
if (x == T) return f;
int use = 0, i;
for (int i = fir[x]; i; i = nex[i])
if (e[i] && h[to[i]] + 1 == h[x]) {
fir[x] = i;
int out = sap(to[i], min(e[i], f - use));
use += out;
e[i] -= out;
e[i ^ 1] += out;
if (use == f || h[T] >= 1000) return use;
}
if (!--vh[h[x]]) h[T] = 1000;
++vh[++h[x]];
fir[x] = las[x];
return use;
}
int main() {
scanf("%d %d %d %d", &na, &nb, &m, &k);
for (int i = 1, ___ = m; i <= ___; ++i) {
int x, y;
scanf("%d %d", &x, &y);
++d[x];
++d[y + na];
to[++top] = y + na, nex[top] = fir[x], fir[x] = top, las[x] = top;
e[top] = 1;
to[++top] = x, nex[top] = fir[y + na], fir[y + na] = top, las[y + na] = top;
e[top] = 0;
}
S = na + nb + 2;
T = S + 1;
int _ = na + nb + 1;
int Ans = 0;
for (int i = 1, ___ = na + nb; i <= ___; ++i)
if (d[i] % k != 0) ++Ans;
for (int i = 1, ___ = na; i <= ___; ++i)
to[++top] = i, nex[top] = fir[0], fir[0] = top, las[0] = top, to[++top] = 0,
nex[top] = fir[i], fir[i] = top, las[i] = top, to[++top] = i,
nex[top] = fir[S], fir[S] = top, las[S] = top, to[++top] = S,
nex[top] = fir[i], fir[i] = top, las[i] = top, to[++top] = T,
nex[top] = fir[0], fir[0] = top, las[0] = top, to[++top] = 0,
nex[top] = fir[T], fir[T] = top, las[T] = top;
for (int i = na + 1, ___ = na + nb; i <= ___; ++i)
to[++top] = _, nex[top] = fir[i], fir[i] = top, las[i] = top, to[++top] = i,
nex[top] = fir[_], fir[_] = top, las[_] = top, to[++top] = _,
nex[top] = fir[S], fir[S] = top, las[S] = top, to[++top] = S,
nex[top] = fir[_], fir[_] = top, las[_] = top, to[++top] = T,
nex[top] = fir[i], fir[i] = top, las[i] = top, to[++top] = i,
nex[top] = fir[T], fir[T] = top, las[T] = top;
to[++top] = 0, nex[top] = fir[_], fir[_] = top, las[_] = top;
e[top] = 10000000;
to[++top] = _, nex[top] = fir[0], fir[0] = top, las[0] = top;
for (int i = 1, ___ = k; i <= ___; ++i) {
int __ = m + m + 2;
for (int j = 1, ___ = na + nb; j <= ___; ++j) {
e[__] = d[j] % k > 0;
++__;
e[__] = 0;
++__;
e[__] = d[j] / k;
++__;
e[__] = 0;
++__;
e[__] = d[j] / k;
++__;
e[__] = 0;
++__;
}
for (int i = 0, ___ = T; i <= ___; ++i) vh[i] = h[i] = 0;
vh[0] = T + 1;
for (int i = 0, ___ = T; i <= ___; ++i) fir[i] = las[i];
while (h[T] < 1000) sap(S, 10000000);
for (int j = 1, ___ = m; j <= ___; ++j)
if (!out[j] && e[j + j] == 0) out[j] = i, e[j + j + 1] = 0;
__ = m + m + 2;
for (int j = 1, ___ = na + nb; j <= ___; ++j) {
d[j] -= d[j] / k;
if (!e[__] && e[__ + 1]) --d[j];
e[__ + 1] = 0;
__ += 6;
}
--k;
e[top] = 0;
}
printf("%d\n", Ans);
for (int i = 1, ___ = m; i <= ___; ++i) printf("%d ", out[i]);
}
|
#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;
}
void check() {
static int cntx[110][110], cnty[110][110];
memset(cntx, 0, sizeof(cntx));
memset(cnty, 0, sizeof(cnty));
for (int i = 1; i <= m; i++) ++cntx[col[i]][x[i]], ++cnty[col[i]][y[i]];
for (int i = 1; i <= n1; i++) {
for (int j = 1; j <= k; j++) writesp(cntx[j][i]);
putchar('\n');
}
for (int i = 1; i <= n2; i++) {
for (int j = 1; j <= k; j++) writesp(cnty[j][i]);
putchar('\n');
}
putchar('\n');
}
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++) {
x[i] = read();
y[i] = read();
if (deg[cur1[x[i]]] == k) cur1[x[i]] = ++cnt, mark[cur1[x[i]]] = -1;
if (deg[cur2[y[i]]] == k) cur2[y[i]] = ++cnt, mark[cur2[y[i]]] = 1;
add_edge(cur1[x[i]], cur2[y[i]], 1, i);
++deg[cur1[x[i]]];
++deg[cur2[y[i]]];
}
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;
const int N = 410;
struct edge {
int from, to, next, f, v;
} e[N * N];
int head[N], tot, S, T;
void add(int x, int y, int f, int v) {
e[++tot] = (edge){x, y, head[x], f, v};
head[x] = tot;
e[++tot] = (edge){y, x, head[y], 0, -v};
head[y] = tot;
}
int dis[N], vis[N];
int q[N * N], from[N];
bool bfs() {
for (int i = (int)(1); i <= (int)(T); i++) dis[i] = (1 << 29), vis[i] = 0;
int h = 0, t = 1;
dis[q[1] = S] = 0;
while (h != t) {
int x = q[++h];
vis[x] = 0;
for (int i = head[x]; i; i = e[i].next)
if (e[i].f && dis[e[i].to] > dis[x] + e[i].v) {
dis[e[i].to] = dis[x] + e[i].v;
from[e[i].to] = i;
if (!vis[e[i].to]) {
q[++t] = e[i].to;
vis[e[i].to] = 1;
}
}
}
if (dis[T] == (1 << 29)) return 0;
int mn = 1e9;
for (int i = from[T]; i; i = from[e[i].from]) mn = min(mn, e[i].f);
for (int i = from[T]; i; i = from[e[i].from]) e[i].f -= mn, e[i ^ 1].f += mn;
return 1;
}
const int M = 5005;
int n, m, k, s;
int x[M], y[M], co[M];
int dx[N], dy[N];
int main() {
scanf("%d%d%d%d", &n, &m, &k, &s);
for (int i = (int)(1); i <= (int)(k); i++) {
scanf("%d%d", &x[i], &y[i]);
dx[x[i]]++;
dy[y[i]]++;
}
int ans = 0;
for (int i = (int)(1); i <= (int)(n); i++) ans += ((dx[i] % s) != 0);
for (int i = (int)(1); i <= (int)(m); i++) ans += ((dy[i] % s) != 0);
printf("%d\n", ans);
for (int i = (int)(s); i >= (int)(1); i--) {
memset(head, 0, sizeof(head));
tot = 1;
S = n + m + 1;
T = S + 1;
for (int j = (int)(1); j <= (int)(k); j++)
if (!co[j]) add(x[j], n + y[j], 1, 0);
for (int j = (int)(1); j <= (int)(n); j++) {
add(S, j, dx[j] / i, 0);
if (dx[j] % i) add(S, j, 1, 1);
}
for (int j = (int)(1); j <= (int)(m); j++) {
add(j + n, T, dy[j] / i, 0);
if (dy[j] % i) add(j + n, T, 1, 1);
}
for (; bfs();)
;
int z = 0;
for (int j = (int)(1); j <= (int)(k); j++)
if (!co[j])
if (!e[z += 2].f) co[j] = i, dx[x[j]]--, dy[y[j]]--;
}
for (int i = (int)(1); i <= (int)(k); i++) printf("%d ", co[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
struct MinCostMaxFlow {
struct edge {
int x, y, c, w;
edge *next, *op;
} g[440000], *ls[405], *fa[405];
int n, S, T, flow, cost, e;
int d[405], inQ[405];
void init(int _n, int _S, int _T) {
n = _n;
S = _S;
T = _T;
e = 0;
for (int i = 0; i < n; i++) ls[i] = NULL;
}
void addedge(int x, int y, int c, int w = 0) {
g[e].x = x;
g[e].y = y;
g[e].c = c;
g[e].w = w;
g[e].op = &g[e + 1];
g[e].next = ls[x];
ls[x] = &g[e++];
g[e].x = y;
g[e].y = x;
g[e].c = 0;
g[e].w = -w;
g[e].op = &g[e - 1];
g[e].next = ls[y];
ls[y] = &g[e++];
}
bool spfa() {
queue<int> q;
for (int i = 0; i < n; i++) {
d[i] = 0x7FFFFFFF;
inQ[i] = 0;
}
q.push(S);
d[S] = 0;
inQ[S] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
inQ[x] = 0;
for (edge *t = ls[x]; t; t = t->next) {
if (t->c && d[t->x] + t->w < d[t->y]) {
d[t->y] = d[t->x] + t->w;
fa[t->y] = t;
if (!inQ[t->y]) {
inQ[t->y] = 1;
q.push(t->y);
}
}
}
}
return d[T] != 0x7FFFFFFF;
}
void aug() {
int nf = 0x7FFFFFFF;
for (int i = T; i != S; i = fa[i]->x) checkmin(nf, fa[i]->c);
for (int i = T; i != S; i = fa[i]->x) {
fa[i]->c -= nf;
fa[i]->op->c += nf;
}
flow += nf;
cost += nf * d[T];
}
void MCMF() {
flow = cost = 0;
while (spfa()) {
aug();
}
}
} flow;
const int N = 405;
int n, m, k, t;
int deg[N], tag[N];
int color[N][N];
vector<pair<int, int> > edge;
int main() {
memset(color, 0xFF, sizeof(color));
scanf("%d%d%d%d", &n, &m, &k, &t);
for (int x, y, i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
edge.push_back(pair<int, int>(x, y));
deg[x]++;
deg[n + y]++;
color[x][n + y] = -2;
}
int ans = 0;
for (int i = 0; i < m + n; i++) {
ans += !!(deg[i] % t);
}
printf("%d\n", ans);
for (int _i = t; _i >= 1; _i--) {
int S = n + m;
int T = n + m + 1;
flow.init(n + m + 2, n + m, n + m + 1);
for (int j = 0; j < n; j++) {
flow.addedge(S, j, deg[j] / _i);
if (deg[j] % _i) flow.addedge(S, j, 1, 1);
}
for (int j = 0; j < m; j++) {
flow.addedge(n + j, T, deg[n + j] / _i);
if (deg[n + j] % _i) flow.addedge(n + j, T, 1, 1);
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < m; k++) {
if (color[j][n + k] == -2) {
flow.addedge(j, n + k, 1);
}
}
}
flow.MCMF();
for (int i = 1; i < flow.e; i += 2) {
if (flow.g[i].x < S && flow.g[i].y < S && flow.g[i].c) {
color[flow.g[i].y][flow.g[i].x] = _i;
deg[flow.g[i].y]--;
deg[flow.g[i].x]--;
}
}
for (int i = 0; i < flow.e; i += 2) {
if ((flow.g[i].x >= S || flow.g[i].y >= S) && !flow.g[i].w) {
assert(!flow.g[i].c);
}
}
}
for (__typeof((edge).begin()) it = (edge).begin(); it != (edge).end(); it++) {
printf("%d ", color[it->first][it->second + n]);
}
}
|
#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 mn = 410, mm = 101000, inf = 1 << 30;
bool vis[mn];
int X[mm], Y[mm], du[mn];
int n, m, K, t, S, T, ans[mm], answer;
int dis[mm], pre[mm], Q[mm];
struct network {
int tt, la[mn], next[mm], y[mm], f[mm], co[mm];
void clear() {
tt = 1;
memset(la, 0, (T + 2) * 4);
}
void add(int i, int j, int u, int v) {
++tt, next[tt] = la[i], la[i] = tt, y[tt] = j, f[tt] = u, co[tt] = v;
++tt, next[tt] = la[j], la[j] = tt, y[tt] = i, f[tt] = 0, co[tt] = -v;
}
} e;
int spfa() {
memset(vis, 0, T + 2);
memset(pre, 0, (T + 2) * 4);
fill(dis + 1, dis + 1 + T, inf);
dis[S] = 0;
int st = 1, ed = 2;
Q[1] = S, vis[S] = 1;
while (st != ed) {
int r = Q[st];
for (int p = e.la[r], i; p; p = e.next[p]) {
if (!e.f[p]) continue;
i = e.y[p];
if (dis[r] + e.co[p] < dis[i]) {
dis[i] = dis[r] + e.co[p], pre[i] = p;
if (!vis[i]) {
Q[ed] = i, vis[i] = 1;
ed = (ed + 1) % (T + 2);
}
}
}
st = (st + 1) % (T + 2);
vis[r] = 0;
}
return dis[T];
}
void repair() {
for (int i = T, p; i != S; i = e.y[p ^ 1]) {
p = pre[i];
--e.f[p], ++e.f[p ^ 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);
++du[X[i]], ++du[Y[i] + n];
}
for (int i = 1; i <= n + m; ++i) answer += (du[i] % t) != 0;
S = n + m + 1, T = S + 1;
while (t) {
e.clear();
for (int i = 1; i <= K; ++i) {
if (ans[i]) continue;
e.add(X[i], Y[i] + n, 1, 0);
}
for (int i = 1; i <= n; ++i) {
e.add(S, i, du[i] / t, 0);
if (du[i] % t != 0) e.add(S, i, 1, 1);
}
for (int i = n + 1; i <= n + m; ++i) {
e.add(i, T, du[i] / t, 0);
if (du[i] % t != 0) e.add(i, T, 1, 1);
}
while (spfa() < inf) repair();
int tot = 0;
for (int i = 1; i <= K; ++i) {
if (ans[i]) continue;
++tot;
if (e.f[tot * 2] == 0) {
ans[i] = t;
--du[X[i]], --du[Y[i] + n];
}
}
--t;
}
printf("%d\n", answer);
for (int i = 1; i <= K - 1; ++i) printf("%d ", ans[i]);
printf("%d\n", ans[K]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, px[5010], py[5010], dx[210], dy[210], c[5010];
int he[210 * 2], ad[5010 * 4], ne[5010 * 4], di[5010 * 4], wi[5010 * 4], t;
void addE(int x, int y, int z, int w) {
++t, ne[t] = he[x], he[x] = t, ad[t] = y, di[t] = z, wi[t] = w;
++t, ne[t] = he[y], he[y] = t, ad[t] = x, di[t] = 0, wi[t] = -w;
}
int q[210 * 210 * 4], pr[210 * 2], ed[210 * 2], d[210 * 2];
bool v[210 * 2];
bool spfa(int s, int t, int c) {
memset(v, 0, sizeof v);
for (int i = 0; i < c; i++) d[i] = 1000000007;
int l = 0, r = 1;
q[0] = s, v[s] = 1, d[s] = 0;
while (l < r) {
int x = q[l++];
v[x] = 0;
for (int p = he[x]; p; p = ne[p])
if (di[p])
if (d[x] + wi[p] < d[ad[p]]) {
d[ad[p]] = d[x] + wi[p], pr[ad[p]] = x, ed[ad[p]] = p;
if (!v[ad[p]]) v[ad[p]] = 1, q[r++] = ad[p];
}
}
return d[t] < 1000000007;
}
int ff(int s, int t, int c) {
int S = 0, T = 0;
while (spfa(s, t, c)) {
int nf = 1000000007;
for (int i = t; i != s; i = pr[i]) nf = min(nf, di[ed[i]]);
S += nf * d[t], T += nf;
for (int i = t; i != s; i = pr[i]) di[ed[i]] -= nf, di[ed[i] ^ 1] += nf;
}
return S;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &s);
for (int i = 0; i < k; i++)
scanf("%d%d", px + i, py + i), dx[--px[i]]++, dy[--py[i]]++;
int S = 0;
for (int i = 0; i < n; i++) S += !!(dx[i] % s);
for (int i = 0; i < m; i++) S += !!(dy[i] % s);
printf("%d\n", S);
for (int i = s; i; i--) {
memset(he, 0, sizeof he), t = 1;
int le = n + m, ri = le + 1;
for (int j = 0; j < k; j++)
if (!c[j]) addE(px[j], n + py[j], 1, 0);
for (int j = 0; j < n; j++) {
addE(le, j, dx[j] / i, 0);
if (dx[j] % i) addE(le, j, 1, 1);
}
for (int j = 0; j < m; j++) {
addE(n + j, ri, dy[j] / i, 0);
if (dy[j] % i) addE(n + j, ri, 1, 1);
}
ff(le, ri, ri + 1);
for (int j = 0, z = 0; j < k; j++)
if (!c[j]) {
z += 2;
if (!di[z]) c[j] = i, dx[px[j]]--, dy[py[j]]--;
}
}
for (int i = 0; i < k; i++) printf("%d%c", c[i], i == k - 1 ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dbv;
int p[2000], f[2000], fi[2000], e[600000], ev[600000], ef[600000], ne[600000],
pf[2000], ec;
int d1[2000], d2[2000];
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 < 2000; 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 < 2000; 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;
fprintf(stderr, "+%d %d\n", p.a, p.b);
if (p.a == 3 && p.b == 3) fprintf(stderr, "@%d %d\n", ev[fi[a]], minl);
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;
fprintf(stderr, "-%d %d\n", p.a, p.b);
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>
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[1100000];
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 = 205;
const int MAXM = 5005;
const int MAXD = 205;
const int MAXN = 2 * N + 2 * MAXM;
int id;
vector<int> lft[N], rht[N];
int deg[MAXN];
int degposta[2 * N];
struct EC {
vector<pair<int, int> > has[2][MAXN];
int deg[2][MAXN], color[MAXM], c[2];
void prep(int d) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < MAXN; j++) has[i][j].resize(d + 1, {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]] = {0, 0};
has[p][x][c[p]] = i;
has[!p][i.first][c[p]] = {x, i.second};
color[i.second] = c[p];
}
int solve(vector<pair<int, int> > &e, vector<int> &res) {
int m = ((int)e.size()), ans = 0;
for (int i = 0; i < m; i++)
ans = max({ans, ++deg[0][e[i].first + 1], ++deg[1][e[i].second + 1]});
prep(ans);
for (int i = 0; i < m; i++) {
int x[2] = {e[i].first + 1, e[i].second + 1};
for (int d = 0; d < 2; 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]] = {x[!d], i + 1};
color[i + 1] = c[0];
}
res.resize(m);
for (int i = 0; i < m; i++) res[i] = color[i + 1];
return ans;
}
};
int main() {
int n, m, k, t;
cin >> n >> m >> k >> t;
id = n + m;
vector<pair<int, int> > orden;
map<pair<int, int>, int> colors;
for (int i = 0; i < n; i++) lft[i].push_back(i);
for (int i = 0; i < m; i++) rht[i].push_back(i + n);
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--, y--;
degposta[x]++, degposta[y + n]++;
int xid = lft[x].back(), yid = rht[y].back();
orden.push_back({xid, yid});
if (++deg[xid] == t) lft[x].push_back(id++);
if (++deg[yid] == t) rht[y].push_back(id++);
}
vector<int> res;
EC ec;
ec.solve(orden, res);
int r = 0;
for (int i = 0; i < n + m; i++) r += degposta[i] % t != 0;
cout << r << '\n';
for (auto e : res) cout << e << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -1 : f, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int buf[30];
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[++buf[0]] = x % 10;
if (!buf[0]) buf[++buf[0]] = 0;
for (; buf[0]; putchar('0' + buf[buf[0]--]))
;
}
const int INF = INT_MAX >> 1;
const int N = 205;
const int T = 205;
const int V = N << 1;
const int K = 5005;
const int E1 = K + N + N;
const int E2 = (E1 * 3 + 1) << 1;
inline int max(int x, int y) { return x > y ? x : y; }
inline int min(int x, int y) { return x < y ? x : y; }
int ans[N][N];
int deg[2][N];
int pos[K][2];
int eid[K];
int sum[T];
int n, m, t, cost, t_, k;
struct network {
int tov[E2], nxt[E2], f[E2], v[E2], r[E2];
int last[V], lab[V];
int S, T, SS, TT, tot;
queue<int> q;
inline void init() {
memset(last, 0, sizeof last), memset(tov, 0, sizeof tov),
memset(nxt, 0, sizeof nxt);
tot = 0, S = 0, T = n + m + 1, SS = T + 1, TT = SS + 1;
}
inline void insert(int x, int y, int full, int rev) {
tov[++tot] = y, nxt[tot] = last[x], f[tot] = full, v[tot] = 0,
r[tot] = tot + rev, last[x] = tot;
}
inline int addedge(int x, int y, int full) {
return insert(x, y, full, 1), insert(y, x, 0, -1), r[tot];
}
inline int build(int x, int y, int L, int U) {
return addedge(SS, y, L), addedge(x, TT, L), addedge(x, y, U - L);
}
inline bool relabel() {
for (int x = S; x <= TT; ++x) lab[x] = 0;
for (lab[SS] = 1, q.push(SS); !q.empty(); q.pop())
for (int x = q.front(), i = last[x], y; i; i = nxt[i])
if (!lab[y = tov[i]] && f[i] - v[i]) lab[y] = lab[x] + 1, q.push(y);
return lab[TT];
}
int aug(int x, int flow) {
if (x == TT) return flow;
int ret = 0;
for (int i = last[x], y; i; i = nxt[i])
if (lab[y = tov[i]] == lab[x] + 1 && f[i] - v[i]) {
int tmp = aug(y, min(flow, f[i] - v[i]));
if (tmp) {
ret += tmp, flow -= tmp;
v[i] += tmp, v[r[i]] -= tmp;
if (!flow) break;
} else
lab[y] = 0;
}
return ret;
}
inline int maxflow() {
int ret = 0;
for (int tmp; relabel();)
for (; tmp = aug(SS, INF); ret += tmp)
;
return ret;
}
} net;
void assign(int t) {
net.init();
for (int i = 1; i <= n; ++i) deg[0][i] = 0;
for (int i = 1; i <= m; ++i) deg[1][i] = 0;
for (int i = 1, x, y; i <= k; ++i)
if (!ans[x = pos[i][0]][y = pos[i][1]])
++deg[0][x], ++deg[1][y], eid[i] = net.build(x, y + n, 0, 1);
for (int i = 1; i <= n; ++i)
net.build(net.S, i, (int)floor((1. * deg[0][i]) / (1. * t)),
(int)ceil((1. * deg[0][i]) / (1. * t)));
for (int i = 1; i <= m; ++i)
net.build(n + i, net.T, (int)floor((1. * deg[1][i]) / (1. * t)),
(int)ceil((1. * deg[1][i]) / (1. * t)));
net.addedge(net.T, net.S, INF), net.maxflow();
for (int i = 1, x, y; i <= k; ++i)
if (!ans[x = pos[i][0]][y = pos[i][1]])
if (net.f[eid[i]] == net.v[eid[i]]) ans[x][y] = t;
}
int main() {
n = read(), m = read(), k = read(), t = read();
for (int i = 1; i <= k; ++i) pos[i][0] = read(), pos[i][1] = read();
for (t_ = t; t_; --t_) assign(t_);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= t; ++j) sum[j] = 0;
for (int j = 1; j <= m; ++j) ++sum[ans[i][j]];
int mx = 0;
for (int j = 1; j <= t; ++j)
for (int k = 1; k <= t; ++k) mx = max(mx, sum[j] - sum[k]);
cost += mx;
}
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= t; ++j) sum[j] = 0;
for (int j = 1; j <= n; ++j) ++sum[ans[j][i]];
int mx = 0;
for (int j = 1; j <= t; ++j)
for (int k = 1; k <= t; ++k) mx = max(mx, sum[j] - sum[k]);
cost += mx;
}
write(cost), putchar('\n');
for (int i = 1; i <= k; ++i)
write(ans[pos[i][0]][pos[i][1]]), putchar("\n "[i < k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void readi(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readll(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
long long qp(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long z = qp(x, y / 2);
z = z * z % 1000000007;
if (y & 1) z = z * x % 1000000007;
return z;
}
struct eg {
int x, y, z, dis, re, id;
} e[100005];
vector<int> bi[100005];
int n, m, i, j, x[100005], y[100005], k, t, c[100005], ans, cnt2, dis[100005],
pre[100005];
vector<int> wyx[100005];
void edg(int x, int y, int z, int dis, int id = 0) {
cnt2++;
e[cnt2] = {x, y, z, dis, cnt2 + 1, id};
bi[x].push_back(cnt2);
cnt2++;
e[cnt2] = {y, x, 0, -dis, cnt2 - 1, 0};
bi[y].push_back(cnt2);
}
int bfs(int s, int t, int &cst) {
cst = 0;
queue<int> q;
q.push(s);
for (i = 1; i <= n + m + 2; i++) {
dis[i] = 1 << 30;
pre[i] = -1;
}
dis[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (i = 0; i < bi[x].size(); i++) {
if (e[bi[x][i]].z && e[bi[x][i]].y != s &&
dis[e[bi[x][i]].y] > dis[x] + e[bi[x][i]].dis) {
dis[e[bi[x][i]].y] = dis[x] + e[bi[x][i]].dis;
pre[e[bi[x][i]].y] = bi[x][i];
q.push(e[bi[x][i]].y);
}
}
}
if (pre[t] == -1) return -1;
int mx = 1 << 30;
for (i = t; i != s; i = e[pre[i]].x) {
mx = min(mx, e[pre[i]].z);
}
for (i = t; i != s; i = e[pre[i]].x) {
cst += mx * e[pre[i]].dis;
e[pre[i]].z -= mx;
e[e[pre[i]].re].z += mx;
}
return mx;
}
int mincostmaxflow(int st, int ed, int &cst) {
cst = 0;
int ans = 0, res, res2;
for (; res = bfs(st, ed, res2) != -1;) ans += res, cst += res2;
return ans;
}
int main() {
cin >> n >> m >> k >> t;
for (i = 1; i <= k; i++) {
cin >> x[i] >> y[i];
y[i] += n;
wyx[x[i]].push_back(y[i]);
wyx[y[i]].push_back(x[i]);
}
for (i = 1; i <= n + m; i++) {
if (wyx[i].size() % t != 0) ans++;
}
cout << ans << endl;
int cc;
if ((t) >= 1)
for (((cc)) = ((t)); ((cc)) >= (1); ((cc))--) {
cnt2 = 0;
if (1 <= (n + m + 2))
for (((i)) = (1); ((i)) <= ((n + m + 2)); ((i))++) bi[i].clear();
if (1 <= (k))
for (((i)) = (1); ((i)) <= ((k)); ((i))++) {
if (c[i]) continue;
edg(x[i], y[i], 1, 0, i);
}
if (1 <= (n))
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
edg(n + m + 1, i, wyx[i].size() / cc, 0);
if (wyx[i].size() % cc != 0) edg(n + m + 1, i, 1, 1);
}
if (n + 1 <= n + m)
for ((i) = (n + 1); (i) <= (n + m); (i)++) {
edg(i, n + m + 2, wyx[i].size() / cc, 0);
if (wyx[i].size() % cc != 0) edg(i, n + m + 2, 1, 1);
}
int rubbish;
mincostmaxflow(n + m + 1, n + m + 2, rubbish);
if (1 <= (cnt2))
for (((i)) = (1); ((i)) <= ((cnt2)); ((i))++) {
if (!e[i].id) continue;
if (c[e[i].id]) continue;
if (!e[i].z) {
c[e[i].id] = cc;
wyx[x[e[i].id]].pop_back();
wyx[y[e[i].id]].pop_back();
}
}
}
for (i = 1; i <= k; i++) cout << c[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
struct MinCostMaxFlow {
struct edge {
int x, y, c, w;
edge *next, *op;
} g[440000], *ls[405], *fa[405];
int n, S, T, flow, cost, e;
int d[405], inQ[405];
void init(int _n, int _S, int _T) {
n = _n;
S = _S;
T = _T;
e = 0;
for (int i = 0; i < n; i++) ls[i] = NULL;
}
void addedge(int x, int y, int c, int w = 0) {
g[e].x = x;
g[e].y = y;
g[e].c = c;
g[e].w = w;
g[e].op = &g[e + 1];
g[e].next = ls[x];
ls[x] = &g[e++];
g[e].x = y;
g[e].y = x;
g[e].c = 0;
g[e].w = -w;
g[e].op = &g[e - 1];
g[e].next = ls[y];
ls[y] = &g[e++];
}
bool spfa() {
queue<int> q;
for (int i = 0; i < n; i++) {
d[i] = 0x7FFFFFFF;
inQ[i] = 0;
}
q.push(S);
d[S] = 0;
inQ[S] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
inQ[x] = 0;
for (edge *t = ls[x]; t; t = t->next) {
if (t->c && d[t->x] + t->w < d[t->y]) {
d[t->y] = d[t->x] + t->w;
fa[t->y] = t;
if (!inQ[t->y]) {
inQ[t->y] = 1;
q.push(t->y);
}
}
}
}
return d[T] != 0x7FFFFFFF;
}
void aug() {
int nf = 0x7FFFFFFF;
for (int i = T; i != S; i = fa[i]->x) checkmin(nf, fa[i]->c);
for (int i = T; i != S; i = fa[i]->x) {
fa[i]->c -= nf;
fa[i]->op->c += nf;
}
flow += nf;
cost += nf * d[T];
}
void MCMF() {
flow = cost = 0;
while (spfa()) {
aug();
}
}
} flow;
const int N = 405;
int n, m, k, t;
int deg[N], tag[N];
int color[N][N];
vector<pair<int, int> > edge;
int main() {
memset(color, 0xFF, sizeof(color));
scanf("%d%d%d%d", &n, &m, &k, &t);
for (int x, y, i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
edge.push_back(pair<int, int>(x, y));
deg[x]++;
deg[n + y]++;
color[x][n + y] = -2;
}
int ans = 0;
for (int i = 0; i < m + n; i++) {
ans += !!(deg[i] % t);
}
printf("%d\n", ans);
for (int _i = t; _i >= 1; _i--) {
int S = n + m;
int T = n + m + 1;
flow.init(n + m + 2, n + m, n + m + 1);
for (int j = 0; j < n; j++) {
flow.addedge(S, j, deg[j] / _i);
if (deg[j] % _i) flow.addedge(S, j, 1, 1);
}
for (int j = 0; j < m; j++) {
flow.addedge(n + j, T, deg[n + j] / _i);
if (deg[n + j] % _i) flow.addedge(n + j, T, 1, 1);
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < m; k++) {
if (color[j][n + k] == -2) {
flow.addedge(j, n + k, 1);
}
}
}
flow.MCMF();
for (int i = 1; i < flow.e; i += 2) {
if (flow.g[i].x < S && flow.g[i].y < S && flow.g[i].c) {
color[flow.g[i].y][flow.g[i].x] = _i;
deg[flow.g[i].y]--;
deg[flow.g[i].x]--;
}
}
}
for (__typeof((edge).begin()) it = (edge).begin(); it != (edge).end(); it++) {
printf("%d ", color[it->first][it->second + n]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline ll read() {
ll x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const ll inf = 0x3f3f3f3f;
int deg[11010], to[11010][210], id[11010][210], col[5010], cur1[210], cur2[210],
n1, n2, m, k, cnt, ans;
inline void adjust(int x, int c1, int c2) {
while (x) {
col[id[x][c1]] = c2;
swap(to[x][c1], to[x][c2]);
swap(id[x][c1], id[x][c2]);
x = to[x][c2];
swap(c1, c2);
}
}
int main() {
n1 = read();
n2 = read();
m = read();
k = read();
deg[0] = k;
cnt = 0;
for (int i = 1; i <= m; i++) {
int x = read(), y = read(), cx = 0, cy = 0;
if (deg[cur1[x]] == k) {
cur1[x] = ++cnt;
deg[cur1[x]] = 0;
}
if (deg[cur2[y]] == k) {
cur2[y] = ++cnt;
deg[cur2[y]] = 0;
}
++deg[cur1[x]];
++deg[cur2[y]];
for (int j = 1; j <= k; j++)
if (!to[cur1[x]][j]) {
cx = j;
break;
}
if (to[cur2[y]][cx]) {
for (int j = 1; j <= k; j++)
if (!to[cur2[y]][j]) {
cy = j;
break;
}
adjust(cur2[y], cx, cy);
}
to[cur1[x]][cx] = cur2[y];
id[cur1[x]][cx] = i;
to[cur2[y]][cx] = cur1[x];
id[cur2[y]][cx] = i;
col[i] = cx;
}
for (int i = 1; i <= cnt; i++)
if (deg[i] < k) ++ans;
printf("%d\n", ans);
for (int i = 1; i <= m; i++) printf("%d ", col[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
struct Cg {
__attribute__((always_inline)) inline char operator()() { return getchar(); }
};
struct Cp {
__attribute__((always_inline)) inline void operator()(char x) { putchar(x); }
};
__attribute__((always_inline)) inline bool IS(char x) {
return x == 10 || x == 13 || x == ' ';
}
template <typename T>
struct Fr {
T P;
__attribute__((always_inline)) inline Fr &operator,(int &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator int() {
int x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(long long &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator long long() {
long long x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
__attribute__((always_inline)) inline operator char() {
char x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
__attribute__((always_inline)) inline Fr &operator,(double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator double() {
double x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(long double &x) {
x = 0;
unsigned char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
__attribute__((always_inline)) inline operator long double() {
long double x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(unsigned int &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
__attribute__((always_inline)) inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
__attribute__((always_inline)) inline Fr &operator,(unsigned long long &x) {
x = 0;
unsigned char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
__attribute__((always_inline)) inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
__attribute__((always_inline)) inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(unsigned int x) {
if (x) {
unsigned char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
unsigned char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(unsigned long long x) {
if (x) {
unsigned char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(char x) {
P(x);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(char x) {
P(x);
return *this;
}
__attribute__((always_inline)) inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
__attribute__((always_inline)) inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
const int N = 202;
int n, m, k, s[N][N];
bool e[N][N];
int pans;
int ds[N], dt[N], us[N], ut[N], cs[N][N], ct[N][N];
inline bool chk(int x, int y, int z) { return x >= z && x * k <= y; }
inline unsigned int rr() {
static unsigned int S = 192608170;
S ^= S << 13;
S ^= S >> 17;
S ^= S << 5;
return S;
}
const int qm = 511;
int qb, qe, q[qm + 1];
bool vis[N * 2];
inline void add(int x) {
if (!vis[x]) q[qe++ & qm] = x, vis[x] = 1;
}
inline void addfs(int x, int c) {
if (!chk(cs[x][c], ds[x], us[x])) add(x);
}
inline void addft(int x, int c) {
if (!chk(ct[x][c], dt[x], ut[x])) add(x + n);
}
int ni[N], mi[N], ki[N];
inline void shuffle(int *S, int n) {
for (int i = 0, iend = 7; i < iend; i++)
std::swap(S[rr() % n + 1], S[rr() % n + 1]);
}
inline void fixs(int x) {
int l = us[x], r = us[x] + bool(ds[x] % k), i, j;
shuffle(mi, m);
for (int i_ = 1, i_end = m; i_ <= i_end; i_++)
if (i = mi[i_], cs[x][s[x][i]] > r) {
do j = rr() % k + 1;
while (cs[x][j] >= r);
cs[x][s[x][i]]--;
cs[x][j]++;
ct[i][s[x][i]]--;
ct[i][j]++;
addft(i, s[x][i]);
addft(i, j);
s[x][i] = j;
}
shuffle(ki, k);
for (int i_ = 1, i_end = k; i_ <= i_end; i_++)
for (i = ki[i_]; cs[x][i] < l;) {
do j = rr() % m + 1;
while (cs[x][s[x][j]] <= l);
cs[x][s[x][j]]--;
cs[x][i]++;
ct[j][s[x][j]]--;
ct[j][i]++;
addft(j, s[x][j]);
addft(j, i);
s[x][j] = i;
}
}
inline void fixt(int x) {
int l = ut[x], r = ut[x] + bool(dt[x] % k), i, j;
shuffle(ni, n);
for (int i_ = 1, i_end = n; i_ <= i_end; i_++)
if (i = ni[i_], ct[x][s[i][x]] > r) {
do j = rr() % k + 1;
while (ct[x][j] >= r);
ct[x][s[i][x]]--;
ct[x][j]++;
cs[i][s[i][x]]--;
cs[i][j]++;
addfs(i, s[i][x]);
addfs(i, j);
s[i][x] = j;
}
shuffle(ki, k);
for (int i_ = 1, i_end = k; i_ <= i_end; i_++)
for (i = ki[i_]; ct[x][i] < l;) {
do j = rr() % n + 1;
while (ct[x][s[j][x]] <= l);
ct[x][s[j][x]]--;
ct[x][i]++;
cs[j][s[j][x]]--;
cs[j][i]++;
addfs(j, s[j][x]);
addfs(j, i);
s[j][x] = i;
}
}
void Modify(int x, int y) {
ds[x]++, dt[y]++;
int u = ds[x] % k;
if (u == 0)
pans--, us[x]++;
else if (u == 1)
pans++;
u = dt[y] % k;
if (u == 0)
pans--, ut[y]++;
else if (u == 1)
pans++;
e[x][y] = 1;
for (int i = 1, iend = k; i <= iend; i++)
if (chk(cs[x][i] + 1, ds[x], us[x]) && chk(ct[y][i] + 1, dt[y], ut[y])) {
s[x][y] = i;
cs[x][i]++, ct[y][i]++;
return;
}
int gg = rr() % k + 1;
s[x][y] = gg, cs[x][gg]++, ct[y][gg]++;
qb = qe = 0;
if (!chk(cs[x][s[x][y]], ds[x], us[x])) add(x);
if (!chk(ct[y][s[x][y]], dt[y], ut[y])) add(y + n);
while (qb < qe) {
int x = q[qb++ & qm];
if (x <= n)
fixs(x);
else
fixt(x - n);
vis[x] = 0;
}
}
int main() {
int q;
in, n, m, q, k;
if (k == 1) {
out, 0, '\n';
for (int i = 1, iend = q; i <= iend; i++) out, 1, ' ';
out, '\n';
return 0;
}
for (int i = 1, iend = n; i <= iend; i++) ni[i] = i;
for (int i = 1, iend = m; i <= iend; i++) mi[i] = i;
for (int i = 1, iend = k; i <= iend; i++) ki[i] = i;
std::vector<std::pair<int, int> > e;
for (int i = 1, iend = q; i <= iend; i++) {
int x, y;
in, x, y;
Modify(x, y);
e.push_back(std::make_pair(x, y));
}
out, pans, '\n';
for (__typeof((e).end()) i = (e).begin(); i != (e).end(); ++i)
out, s[i->first][i->second], ' ';
out, '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5, M = N << 10, inf = 0x7fffffff;
int t[M], f[M], nxt[M], lst[N], used[N], l;
void add(int x, int y, int z) {
t[++l] = y;
f[l] = z;
nxt[l] = lst[x];
lst[x] = l;
t[++l] = x;
f[l] = 0;
nxt[l] = lst[y];
lst[y] = l;
}
void link(int x, int y, int down, int up) {
add(x, y, up - down);
used[y] += down;
used[x] -= down;
}
int n1, n2, m, k, dis[N], q[N], d1[N], d2[N];
int S, T, ss, tt, x[M], y[M], col[M];
bool bfs(int st, int ed) {
for (int i = S; i <= tt; i++) dis[i] = 0;
int i = 0, j = 1;
dis[st] = 1;
q[1] = st;
while (i < j)
for (int k = lst[q[++i]]; k; k = nxt[k])
if (f[k] && !dis[t[k]]) dis[t[k]] = dis[q[i]] + 1, q[++j] = t[k];
return dis[ed];
}
int dinic(int x, int T, int y) {
if (x == T) return y;
int now = 0;
for (int i = lst[x]; i; i = nxt[i])
if (f[i] && dis[t[i]] == dis[x] + 1) {
int k = dinic(t[i], T, min(y, f[i]));
f[i] -= k;
f[i ^ 1] += k;
y -= k;
now += k;
if (!y) break;
}
if (!now) dis[x] = -1;
return now;
}
void build(int c) {
l = 1;
for (int i = S; i <= tt; i++) lst[i] = used[i] = 0;
for (int i = 1; i <= m; i++)
if (!col[i]) link(x[i], y[i] + n1, 0, 1);
for (int i = 1; i <= n1; i++)
link(S, i, d1[i] / c, d1[i] / c + (d1[i] % c > 0));
for (int i = 1; i <= n2; i++)
link(i + n1, T, d2[i] / c, d2[i] / c + (d2[i] % c > 0));
add(T, S, inf);
for (int i = S; i <= T; i++) {
if (used[i] > 0) add(ss, i, used[i]);
if (used[i] < 0) add(i, tt, -used[i]);
}
}
void flow() {
while (bfs(ss, tt)) dinic(ss, tt, inf);
}
void rebuild() {
int tot = 1 + n1 * 2 + n2 * 2;
for (int i = 1; i <= m; i++)
if (!col[i]) tot += 2;
for (int i = tot + 1; i <= l; i++) f[i] = 0;
}
void max_flow() {
while (bfs(S, T)) dinic(S, T, inf);
}
void color(int c) {
int tot = 0;
for (int i = 1; i <= m; i++)
if (!col[i]) {
tot += 2;
if (!f[tot]) {
col[i] = c;
d1[x[i]]--;
d2[y[i]]--;
}
}
}
int main() {
scanf("%d%d%d%d", &n1, &n2, &m, &k);
S = 0;
T = n1 + n2 + 1;
ss = T + 1;
tt = ss + 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
d1[x[i]]++;
d2[y[i]]++;
}
int ans = 0;
for (int i = 1; i <= n1; i++) ans += (d1[i] % k) > 0;
for (int i = 1; i <= n2; i++) ans += (d2[i] % k) > 0;
printf("%d\n", ans);
for (int i = 1; i <= k; i++) {
build(k - i + 1);
flow();
rebuild();
max_flow();
color(i);
}
for (int i = 1; i <= m; i++) printf("%d ", col[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, K, las[101000], nxt[101000], to[101000], dat[101000], id[101000],
S, T, tot = 1, d[101000], SS, TT, fl[101000], bz[101000], que[101000],
e[101000][2], use[101000], ans[101000];
int co[610][310];
void putin(int x, int y, int z1) {
nxt[++tot] = las[x];
las[x] = tot;
to[tot] = y;
dat[tot] = z1;
nxt[++tot] = las[y];
las[y] = tot;
to[tot] = x;
dat[tot] = 0;
}
void link(int x, int y, int z1, int z2) {
putin(x, y, z2 - z1);
fl[x] = fl[x] - z1;
fl[y] = fl[y] + z1;
}
bool bfs() {
int he = 0, ta = 1;
memset(bz, 0, sizeof(bz));
que[1] = SS;
bz[SS] = 1;
while (he < ta) {
int x = que[++he];
for (int i = las[x]; i; i = nxt[i])
if (dat[i]) {
int y = to[i];
if (bz[y] == 0) {
que[++ta] = y;
bz[y] = bz[x] + 1;
}
}
}
return bz[TT] > 0;
}
int dfs(int x, int t) {
if (x == TT) return t;
int ans = 0;
for (int i = las[x]; i; i = nxt[i])
if (dat[i]) {
int y = to[i];
if (bz[y] != bz[x] + 1) continue;
int qq = dfs(y, min(t, dat[i]));
dat[i] -= qq;
dat[i ^ 1] += qq;
ans += qq;
t -= qq;
if (t == 0) return ans;
}
if (ans == 0) bz[x] = -1;
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &m, &t, &K);
for (int i = 1; i <= t; i++) scanf("%d%d", &e[i][0], &e[i][1]);
S = n + m + 1;
T = S + 1;
SS = T + 1;
TT = SS + 1;
for (int k = 1; k <= K; k++) {
memset(d, 0, sizeof(d));
memset(fl, 0, sizeof(fl));
memset(las, 0, sizeof(las));
tot = 1;
for (int i = 1; i <= t; i++)
if (!use[i]) {
link(e[i][0], n + e[i][1], 0, 1);
d[e[i][0]]++;
d[n + e[i][1]]++;
id[i] = tot ^ 1;
}
for (int i = 1; i <= n; i++)
link(S, i, d[i] / (K - k + 1), (d[i] - 1) / (K - k + 1) + 1);
for (int i = 1; i <= m; i++)
link(i + n, T, d[i + n] / (K - k + 1), (d[i + n] - 1) / (K - k + 1) + 1);
for (int i = 1; i <= T; i++)
if (fl[i] > 0)
putin(SS, i, fl[i]);
else
putin(i, TT, -fl[i]);
link(T, S, 0, 0x7fffffff);
while (bfs()) dfs(SS, 0x7fffffff);
for (int i = 1; i <= t; i++)
if (use[i] == 0 && dat[id[i]] == 0) ans[i] = k, use[i] = 1;
}
for (int i = 1; i <= t; i++) {
co[e[i][0]][ans[i]]++;
co[e[i][1] + n][ans[i]]++;
}
int ans1 = 0;
for (int i = 1; i <= n + m; i++) {
int mx = 0;
for (int j = 1; j <= K; j++)
for (int k = j + 1; k <= K; k++) mx = max(mx, abs(co[i][j] - co[i][k]));
ans1 += mx;
}
printf("%d\n", ans1);
for (int i = 1; i <= t; i++) printf("%d ", ans[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
class edge {
public:
int e, nxt, cap;
edge(int e1 = -1, int nxt1 = -1, int cap1 = 0) {
e = e1, nxt = nxt1, cap = cap1;
}
};
int S, T, n, m, K, t, ss, tt;
int dep[410], degl[410], degr[410];
bool vis[410];
int id[210][210];
class graph {
public:
edge g[100000];
int head[410], tmpcnt;
int cur[410];
void init() {
memset(head, 255, sizeof(head));
tmpcnt = 0;
}
void addedge(int s, int e, int cap) {
if (cap == 0) return;
g[tmpcnt] = edge(e, head[s], cap), head[s] = tmpcnt++;
g[tmpcnt] = edge(s, head[e], 0), head[e] = tmpcnt++;
}
bool bfs() {
memset(vis, 0, sizeof(vis));
memset(dep, 0, sizeof(dep));
queue<int> q;
q.push(S);
vis[S] = 1;
while (!q.empty()) {
int fr = q.front();
q.pop();
for (int i = head[fr]; i != -1; i = g[i].nxt) {
if (g[i].cap > 0 && !vis[g[i].e]) {
dep[g[i].e] = dep[fr] + 1;
vis[g[i].e] = 1;
q.push(g[i].e);
}
}
}
return vis[T];
}
int dfs(int np, int maxflow) {
int f;
int flow = 0;
if (np == T || !maxflow) return maxflow;
for (int i = cur[np]; i != -1; i = g[i].nxt) {
cur[np] = i;
if (g[i].cap > 0 && dep[g[i].e] == dep[np] + 1 &&
(f = dfs(g[i].e, min(g[i].cap, maxflow))) > 0) {
g[i].cap -= f;
g[i ^ 1].cap += f;
flow += f;
maxflow -= f;
if (!maxflow) break;
}
}
return flow;
}
int dinic() {
int out = 0;
while (bfs()) memcpy(cur, head, sizeof(cur)), out += dfs(S, INF);
return out;
}
} G;
int st[5010], ed[5010], ans[5010], cntl[210], cntr[210];
int main() {
scanf("%d%d%d%d", &n, &m, &K, &t);
G.init();
for (int i = 1; i <= K; i++) {
scanf("%d%d", &st[i], &ed[i]);
degl[st[i]]++;
degr[ed[i]]++;
id[st[i]][ed[i]] = i;
G.addedge(st[i], ed[i] + n, 1);
}
int ret = 0, basL = 0, basR = 0;
for (int i = 1; i <= n; i++) ret += (degl[i] % t != 0), basL += degl[i] / t;
for (int i = 1; i <= m; i++) ret += (degr[i] % t != 0), basR += degr[i] / t;
printf("%d\n", ret);
S = n + m + 1;
T = n + m + 2;
ss = n + m + 3;
tt = n + m + 4;
for (int i = t; i >= 1; i--) {
G.init();
for (int j = 1; j <= K; j++)
if (!ans[j]) G.addedge(st[j], ed[j] + n, 1);
for (int j = 1; j <= n; j++) {
G.addedge(S, j, degl[j] / i);
G.addedge(ss, T, degl[j] / i);
if (degl[j] % i) G.addedge(ss, j, 1);
}
for (int j = 1; j <= m; j++) {
G.addedge(S, tt, degr[j] / i);
G.addedge(j + n, T, degr[j] / i);
if (degr[j] % i) G.addedge(j + n, tt, 1);
}
G.addedge(tt, ss, INF);
G.dinic();
for (int j = 1; j <= n; j++) {
for (int k = G.head[j]; k != -1; k = G.g[k].nxt) {
int v = G.g[k].e;
if (v > n && v <= n + m) {
if (!G.g[k].cap && !ans[id[j][v - n]])
ans[id[j][v - n]] = i, degl[j]--, degr[v - n]--;
}
}
}
}
for (int i = 1; i <= K; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405, K = 5005, inf = 1e9 + 7;
int n, m, k, t, S, T, tot;
int de[N], hd[N], dis[N], fl[N], pre[N];
bool vis[N];
struct point {
int x, y, c;
} a[K];
struct edge {
int n, v, flow, w;
} e[K << 2];
void add(int u, int v, int flow, int w) {
e[++tot] = (edge){hd[u], v, flow, w}, hd[u] = tot;
e[++tot] = (edge){hd[v], u, 0, -w}, hd[v] = tot;
}
bool SPFA() {
memset(fl + 1, 0, T << 2), memset(dis + 1, 63, T << 2), memset(vis + 1, 0, T);
queue<int> Q;
Q.push(S);
fl[S] = inf, dis[S] = 0;
int u;
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int i = hd[u]; i; i = e[i].n)
if (e[i].flow && dis[e[i].v] > dis[u] + e[i].w) {
dis[e[i].v] = dis[u] + e[i].w;
pre[e[i].v] = i, fl[e[i].v] = min(fl[u], e[i].flow);
if (!vis[e[i].v]) Q.push(e[i].v), vis[e[i].v] = 1;
}
vis[u] = 0;
}
if (!fl[T]) return 0;
u = T;
int nf = fl[T];
while (u ^ S) {
e[pre[u]].flow -= nf, e[pre[u] ^ 1].flow += nf;
u = e[pre[u] ^ 1].v;
}
return 1;
}
void solve(int nt) {
tot = 1;
memset(hd + 1, 0, T << 2);
for (int i = 1; i <= k; ++i)
if (!a[i].c) add(a[i].x, n + a[i].y, 1, 0);
for (int i = 1; i <= n; ++i)
if (de[i]) add(S, i, de[i] / nt, 0), (de[i] % nt && (add(S, i, 1, 1), 1));
for (int i = 1; i <= m; ++i)
if (de[i + n])
add(i + n, T, de[i + n] / nt, 0),
(de[i + n] % nt && (add(i + n, T, 1, 1), 1));
while (SPFA())
;
int now = 2;
for (int i = 1; i <= k; ++i)
if (!a[i].c)
(!e[now].flow && (a[i].c = nt, de[a[i].x]--, de[a[i].y + n]--, 1)),
now += 2;
}
int main() {
cin >> n >> m >> k >> t;
for (int i = 1; i <= k; ++i)
cin >> a[i].x >> a[i].y, de[a[i].x]++, de[a[i].y + n]++;
S = n + m + 1, T = n + m + 2;
int ans = 0;
for (int i = 1; i <= n + m; ++i) ans += (de[i] % t != 0);
cout << ans << '\n';
for (int i = t; i >= 1; --i) solve(i);
for (int i = 1; i <= k; ++i) cout << a[i].c << ' ';
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;
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_source, inf - sum_lhs, -1);
dinic.AddEdge(dummy_source, dummy_sink, inf, -1);
dinic.AddEdge(dummy_sink, sink, inf - sum_rhs, -1);
assert(dinic.MaxFlow(source, sink) == inf);
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 read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch - '0'), ch = getchar();
return x;
}
int nA, nB, m, k, ans, x, y, c1, c2, cnt;
int deg[310 << 1], be[90010], w[310], w2[310];
int id[10005][310], f[10005][310];
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() {
nA = read(), nB = read(), m = read(), k = read();
for (int i = 1; i <= m; ++i) {
x = read(), y = read();
if (deg[x] % k == 0) w[x] = ++cnt;
if (deg[nA + y] % k == 0) w2[y] = ++cnt;
deg[x]++, deg[nA + y]++;
x = w[x], y = w2[y];
c1 = 0, c2 = 0;
for (int j = 1; j <= k; ++j)
if (!f[x][j]) {
c1 = j;
break;
}
for (int j = 1; j <= k; ++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; i <= nA + nB; ++i) ans += (bool)(deg[i] % k);
printf("%d\n", ans);
for (int i = 1; i <= m; ++i) printf("%d ", be[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
const int M = 205, MAXE = 5350 * 3, MAXV = MAXE * 3;
int t, d1[M], d2[M], u[5350], v[5350];
class MinCostFlow {
public:
int V, E;
int cap[MAXE];
int cost[MAXE], dist[MAXV], pot[MAXV];
int to[MAXE], prev[MAXE], last[MAXV], path[MAXV];
bool used[MAXV];
priority_queue<pair<int, int> > q;
MinCostFlow(int n) {
V = n;
E = 0;
for (int(i) = 0; (i) < (int)(V); (i)++) last[i] = -1;
}
void add_edge(int x, int y, int w, int c) {
cap[E] = w;
cost[E] = c;
to[E] = y;
prev[E] = last[x];
last[x] = E;
E++;
cap[E] = 0;
cost[E] = -c;
to[E] = x;
prev[E] = last[y];
last[y] = E;
E++;
}
pair<int, int> search(int s, int t) {
int ansf = 0;
int ansc = 0;
for (int(i) = 0; (i) < (int)(V); (i)++) used[i] = false;
for (int(i) = 0; (i) < (int)(V); (i)++) dist[i] = 1 << 30;
dist[s] = 0;
path[s] = -1;
q.push(make_pair(0, s));
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (used[x]) continue;
used[x] = true;
for (int e = last[x]; e >= 0; e = prev[e])
if (cap[e] > 0) {
int tmp = dist[x] + cost[e] + pot[x] - pot[to[e]];
if (tmp < dist[to[e]] && !used[to[e]]) {
dist[to[e]] = tmp;
path[to[e]] = e;
q.push(make_pair(-dist[to[e]], to[e]));
}
}
}
for (int(i) = 0; (i) < (int)(V); (i)++) pot[i] += dist[i];
if (used[t]) {
ansf = 1 << 30;
for (int e = path[t]; e >= 0; e = path[to[e ^ 1]])
ansf = min(ansf, cap[e]);
for (int e = path[t]; e >= 0; e = path[to[e ^ 1]]) {
ansc += cost[e] * ansf;
cap[e] -= ansf;
cap[e ^ 1] += ansf;
}
}
return make_pair(ansf, ansc);
}
pair<int, int> mincostflow(int s, int t) {
int ansf = 0;
int ansc = 0;
for (int(i) = 0; (i) < (int)(V); (i)++) pot[i] = 0;
while (1) {
pair<int, int> p = search(s, t);
if (!used[t]) break;
ansf += p.first;
ansc += p.second;
}
return make_pair(ansf, ansc);
}
};
int used[5350];
int main() {
scanf("%d%d%d%d", &n, &m, &k, &t);
for (int i = 0; i < k; i++) {
scanf("%d%d", u + i, v + i);
d1[u[i]]++;
d2[v[i]]++;
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (d1[i] % t != 0) ans++;
for (int i = 1; i <= m; i++)
if (d2[i] % t != 0) ans++;
printf("%d\n", ans);
for (int i = t; i; i--) {
MinCostFlow mcf = MinCostFlow(M * 2);
for (int(j) = 0; (j) < (int)(k); (j)++)
if (!used[j]) {
mcf.add_edge(u[j], v[j] + n, 1, 0);
}
for (int j = 1; j <= n; j++) {
mcf.add_edge(0, j, d1[j] / i, 0);
if (d1[j] % i != 0) mcf.add_edge(0, j, 1, 1);
}
for (int j = 1; j <= m; j++) {
mcf.add_edge(j + n, m + n + 1, d2[j] / i, 0);
if (d2[j] % i != 0) mcf.add_edge(j + n, m + n + 1, 1, 1);
}
mcf.mincostflow(0, m + n + 1);
for (int j = 0, z = 0; j < k; j++)
if (!used[j]) {
if (!mcf.cap[z]) {
used[j] = i;
d1[u[j]]--;
d2[v[j]]--;
}
z += 2;
}
}
for (int(i) = 0; (i) < (int)(k); (i)++) printf("%d ", used[i]);
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]]++;
}
for (int i = 1; i <= K; i++)
for (int j = i + 1; j <= K; j++)
if (a[i] == a[j] && b[i] == b[j]) {
printf("%d %d %d %d %d %d\n", i, j, a[i], b[i], a[j], b[j]);
}
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), kt++;
}
int kt1 = 0;
for (int j = 1; j <= m; j++) {
add(j + n, de, deg1[j] / i, 0);
kt1 += deg1[j] / i;
if (deg1[j] % i) add(j + n, de, 1, 1), kt1++;
}
kt = min(kt, kt1);
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) {
if (col[j][y - n]) continue;
col[j][y - n] = i;
deg[j]--, deg1[y - n]--;
}
}
}
}
}
if (mx != K) printf("%d %d\n", mx, K);
for (int i = 1; i <= K; i++) printf("%d ", col[a[i]][b[i]]);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Read(T &x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T>
inline bool CheckMax(T &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool CheckMin(T &a, const T &b) {
return a > b ? a = b, true : false;
}
const int N = 405;
const int M = 100005;
const int inf = 0x3f3f3f3f;
namespace Flow {
struct Edge {
int p, v, w;
} e[M];
int S, T, V, ql, qr, e_cnt, q[N], hed[N], cur[N], dis[N];
inline void Init(int n) {
V = n, e_cnt = 1;
for (int i = 0; i < V; ++i) {
hed[i] = 0;
}
}
inline void AddEdge(int x, int y, int w) {
e[++e_cnt] = {y, hed[x], w}, hed[x] = e_cnt;
e[++e_cnt] = {x, hed[y], 0}, hed[y] = e_cnt;
}
inline bool BFS() {
for (int i = 0; i < V; ++i) {
dis[i] = 0;
}
dis[q[ql = 0] = S] = qr = 1;
while (ql ^ qr) {
int x = q[ql++];
for (int i = hed[x]; i; i = e[i].v) {
if (e[i].w && !dis[e[i].p]) {
dis[q[qr++] = e[i].p] = dis[x] + 1;
}
}
}
return dis[T];
}
inline int DFS(int x, int f) {
if (x == T) {
return f;
}
int r = 0, d;
for (int &i = cur[x]; i; i = e[i].v) {
if (e[i].w && dis[e[i].p] == dis[x] + 1) {
d = DFS(e[i].p, min(f - r, e[i].w)), r += d, e[i].w -= d, e[i ^ 1].w += d;
if (r == f) {
return r;
}
}
}
return dis[x] = -1, r;
}
inline int Dinic() {
int r = 0;
while (BFS()) {
for (int i = 0; i < V; ++i) {
cur[i] = hed[i];
}
r += DFS(S, inf);
}
return r;
}
} // namespace Flow
using namespace Flow;
int n, m, k, t, SS, TT, ans[M], deg[2][N], idx[N][N], tag[N][N];
inline void Solve(int x) {
Init(n + m + 4);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (idx[i][j] && !ans[idx[i][j]]) {
tag[i][j] = e_cnt + 1, AddEdge(i, j + n, 1);
}
}
}
for (int i = 0; i < n; ++i) {
AddEdge(S, i, deg[0][i] / x);
AddEdge(SS, T, deg[0][i] / x);
if (deg[0][i] % x) {
AddEdge(SS, i, 1);
}
}
for (int i = 0; i < m; ++i) {
AddEdge(S, TT, deg[1][i] / x);
AddEdge(i + n, T, deg[1][i] / x);
if (deg[1][i] % x) {
AddEdge(i + n, TT, 1);
}
}
AddEdge(TT, SS, inf);
Dinic();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (idx[i][j] && !ans[idx[i][j]] && !e[tag[i][j]].w) {
--deg[0][i], --deg[1][j], ans[idx[i][j]] = x;
}
}
}
}
int cnt[N][N], u[M], v[M];
int main() {
Read(n), Read(m), Read(k), Read(t);
for (int i = 1, x, y; i <= k; ++i) {
Read(x), Read(y), --x, --y;
u[i] = x, v[i] = y;
++deg[0][x], ++deg[1][y];
idx[x][y] = i;
}
S = n + m, T = n + m + 1, SS = n + m + 2, TT = n + m + 3;
int ret = 0;
for (int i = 0; i < n; ++i) {
if (deg[0][i] % t) {
++ret;
}
}
for (int i = 0; i < m; ++i) {
if (deg[1][i] % t) {
++ret;
}
}
printf("%d\n", ret);
for (int i = t; i; --i) {
Solve(i);
}
for (int i = 1; i <= k; ++i) {
printf("%d%c", ans[i], i == k ? '\n' : ' ');
}
int val = 0;
for (int i = 1; i <= k; ++i) {
++cnt[u[i] + 0][ans[i]];
++cnt[v[i] + n][ans[i]];
}
for (int i = 0; i < n + m; ++i) {
int t_max = 0, t_min = inf;
for (int j = 1; j <= t; ++j) {
CheckMax(t_max, cnt[i][j]);
CheckMin(t_min, cnt[i][j]);
}
val += t_max - t_min;
}
assert(val == ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int maxn = 505;
const int maxm = 5010;
struct E {
int u, v, ans;
E() {}
E(int u, int v, int ans) : u(u), v(v), ans(ans) {}
};
vector<E> ee;
int n, m, k, num;
int deg[maxn];
struct Edge {
int from, to, cap, flow, cost, id;
Edge() {}
Edge(int u, int v, int c, int f, int co, int id)
: from(u), to(v), cap(c), flow(f), cost(co), id(id) {}
};
vector<Edge> edges;
vector<int> G[maxn];
struct MCMF {
int n, m, s, t;
int dis[maxn];
int h[maxn];
int p[maxn];
void init(int n) {
this->n = n;
for (int i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, int cap, int cost, int id) {
edges.push_back(Edge(from, to, cap, 0, cost, id));
edges.push_back(Edge(to, from, 0, 0, -cost, -1));
m = (int)edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}
bool dijkstra(int s, int t, int& max_flow, long long& cost) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
for (int i = 0; i < n; i++) dis[i] = INF;
dis[s] = 0, pq.push(pair<int, int>(0, s));
while (!pq.empty()) {
pair<int, int> u = pq.top();
pq.pop();
int v = u.second;
if (dis[v] < u.first) continue;
for (int i = 0; i < (int)G[v].size(); i++) {
Edge& e = edges[G[v][i]];
if (e.cap > e.flow && dis[e.to] > dis[v] + e.cost + h[v] - h[e.to]) {
dis[e.to] = dis[v] + e.cost + h[v] - h[e.to];
p[e.to] = G[v][i];
pq.push(pair<int, int>(dis[e.to], e.to));
}
}
}
if (dis[t] == INF) return 0;
for (int i = 0; i < n; i++) h[i] += dis[i];
int d = max_flow;
for (int u = t; u != s; u = edges[p[u]].from)
d = min(d, edges[p[u]].cap - edges[p[u]].flow);
max_flow -= d;
cost += (long long)d * (long long)h[t];
for (int u = t; u != s; u = edges[p[u]].from) {
edges[p[u]].flow += d;
edges[p[u] ^ 1].flow -= d;
}
return 1;
}
void MincostMaxflow(int s, int t, int max_flow, long long& cost) {
this->s = s, this->t = t;
cost = 0;
for (int i = 0; i < n; i++) h[i] = 0;
while (dijkstra(s, t, max_flow, cost) && max_flow)
;
}
void check(int now) {
for (int i = 0; i < (int)edges.size(); i += 2) {
Edge e = edges[i];
if (e.cap == e.flow && e.id != -1) {
ee[e.id].ans = now;
deg[e.from]--, deg[e.to]--;
}
}
}
};
int cal(int x, int y) { return (x % y == 0) ? x / y : x / y + 1; }
int main() {
scanf("%d%d%d%d", &n, &m, &k, &num);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
int sz = (int)ee.size();
deg[x]++, deg[y + n]++;
ee.push_back({x, y, -1});
}
int cnt = 0;
for (int i = 0; i < n + m; i++) cnt += (deg[i] % num != 0);
printf("%d\n", cnt);
for (int i = num; i >= 1; i--) {
MCMF solver;
solver.init(n + m + 10);
int s = n + m, t = n + m + 1;
for (int j = 0; j < (int)ee.size(); j++) {
if (ee[j].ans == -1) {
solver.AddEdge(ee[j].u, ee[j].v + n, 1, 0, j);
}
}
for (int j = 0; j < n; j++) {
solver.AddEdge(s, j, deg[j] / i, 0, -1);
if (deg[j] % i != 0) solver.AddEdge(s, j, 1, 1, -1);
}
for (int j = 0; j < m; j++) {
solver.AddEdge(j + n, t, deg[j + n] / i, 0, -1);
if (deg[j + n] % i != 0) solver.AddEdge(j + n, t, 1, 1, -1);
}
long long cost = 0;
solver.MincostMaxflow(s, t, INF, cost);
solver.check(i);
}
for (int i = 0; i < k; i++) printf("%d ", ee[i].ans);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x;
scanf("%d", &x);
return x;
}
inline void writeln(int x) { printf("%d\n", x); }
inline void write(int x) { printf("%d ", x); }
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) {
putchar('0'), putchar('\n');
for (register int i = (1); i <= int(k); ++i) putchar('1'), putchar(' ');
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]), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 5555;
const long long K = 222;
pair<long long, long long> g[2][N][K];
long long ans[N];
long long deg[2][N], curV[2][N];
long long n, m, k, t;
void dfs(long long part, long long v, const vector<long long> c) {
long long u = g[part][v][c[part]].first;
swap(g[part][v][c[part]], g[part][v][c[part ^ 1]]);
if (u == -1) {
return;
}
dfs(part ^ 1, u, c);
}
void add_edge(long long v, long long u, long long id) {
long long c1 = -1, c2 = -1;
auto set_clr = [&]() {
g[0][v][c2] = {u, id};
g[1][u][c2] = {v, id};
};
for (long long i = 0; i < t; i++) {
if (g[0][v][i].first == -1) {
c2 = i;
}
if (g[1][u][i].first == -1) {
c1 = i;
}
if (c1 != -1 && c1 == c2) {
set_clr();
return;
}
}
assert(c1 != -1 && c2 != -1);
dfs(1, u, {c1, c2});
set_clr();
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < N; j++) {
for (long long k = 0; k < K; k++) {
g[i][j][k] = {-1, -1};
}
}
}
cin >> n >> m >> k >> t;
vector<pair<long long, long long>> edges(k);
long long cur_size1 = 0, cur_size2 = 0;
long long res = 0;
for (long long i = 0; i < k; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
edges[i] = {v, u};
if (deg[0][v] % t == 0) {
curV[0][v] = cur_size1++;
}
if (deg[1][u] % t == 0) {
curV[1][u] = cur_size2++;
}
deg[0][v]++;
deg[1][u]++;
add_edge(curV[0][v], curV[1][u], i);
}
for (long long v = 0; v < cur_size1; v++) {
for (long long clr = 0; clr < t; clr++) {
if (g[0][v][clr].first == -1) continue;
ans[g[0][v][clr].second] = clr + 1;
}
}
for (long long i = 0; i < n; i++) {
res += deg[0][i] % t != 0;
}
for (long long i = 0; i < m; i++) {
res += deg[1][i] % t != 0;
}
cout << res << '\n';
for (long long i = 0; i < k; i++) {
assert(ans[i] != 0);
cout << ans[i] << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const long long INF_LL = 1000000000000000000LL;
const double pi = 2 * acos(0.0);
template <class T>
void smin(T& a, T b) {
if (a > b) a = b;
}
template <class T>
void smax(T& a, T b) {
if (a < b) a = b;
}
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
void outp(const vector<T>& v) {
for (int i(0), _b(int((v).size())); i < _b; ++i)
cout << v[i] << (i + 1 == int((v).size()) ? '\n' : ' ');
}
template <class T>
void outp(T* v, int n) {
for (int i(0), _b(n); i < _b; ++i) cout << *v++ << (i + 1 == n ? '\n' : ' ');
}
const int h = 200;
int n, m, k, t;
int deg[2 * h];
template <int N, int M, class T>
struct Flow {
struct Edge {
int b, next;
T cap, f;
int phase;
Edge(int b = -1, T cap = 0, int next = -1)
: b(b), next(next), cap(cap), f(0), phase(0) {}
T rem() { return phase == 0 ? cap - f : 0; }
} E[2 * M];
int n, m;
int head[N], d[N], q[N];
T inf, eps;
bool zero(T x) { return x <= eps && -x <= eps; }
void init(int nn, T tinf, T teps = 0) {
n = nn;
m = 0;
memset(head, -1, sizeof head);
inf = tinf;
eps = teps;
}
void add(int a, int b, T cap) {
if (m < 2 * k) ++deg[a], ++deg[b];
E[m] = Edge(b, cap, head[a]);
head[a] = m++;
E[m] = Edge(a, 0, head[b]);
head[b] = m++;
}
bool bfs(int s, int t) {
memset(d, -1, sizeof d);
q[0] = s;
d[s] = 1;
for (int qa = 0, qb = 1; qa < qb; ++qa) {
int u = q[qa], v;
for (int e = head[u]; e >= 0; e = E[e].next)
if (!zero(E[e ^ 1].rem()) && d[v = E[e].b] == -1) {
d[q[qb++] = v] = d[u] + 1;
if (v == t) return true;
}
}
return false;
}
void inc(int e, int w) {
E[e].f += w;
E[e ^ 1].f -= w;
}
T dfs(int s, int t, T flow) {
if (s == t) return flow;
T res = 0, w;
for (int& e = q[s]; e >= 0; e = E[e].next)
if (!zero(E[e].rem()) && d[E[e].b] == d[s] - 1)
if (!zero(w = dfs(E[e].b, t, min(E[e].rem(), flow)))) {
res += w;
flow -= w;
inc(e, w);
if (zero(flow)) break;
}
return res;
}
bool fix_flow(int u) {
if (d[u] == 0) return false;
d[u] = 0;
int eu = 2 * (k + u);
if (E[eu].f > deg[u] / t) {
inc(eu, -1);
return true;
}
int v, w;
for (int e = head[u]; e >= 0; e = E[e].next) {
v = E[e].b;
if (E[e].phase == 0 && !E[e].f && d[v] == -1) {
d[v] = 0;
for (int r = head[v]; r >= 0; r = E[r].next)
if (E[r].phase == 0 && E[r].f && fix_flow(E[r].b)) {
w = E[r].f > 0 ? -1 : 1;
inc(r, w);
inc(e, w);
return true;
}
}
}
return false;
}
T max_flow(int s, int t) {
for (int i(0), _b(m); i < _b; ++i) E[i].f = 0;
T res = 0;
while (bfs(t, s)) {
for (int i(0), _b(n); i < _b; ++i) q[i] = head[i];
res += dfs(s, t, inf);
}
for (int i(0), _b(n - 2); i < _b; ++i)
while (E[2 * (k + i)].f < deg[i] / ::t) {
memset(d, -1, sizeof d);
d[n - 2] = d[n - 1] = 0;
fix_flow(i);
inc(2 * (k + i), 1);
}
return res;
}
};
Flow<2 * h + 2, 5000 + 2 * h, int> g;
int main() {
scanf("%d%d%d%d", &n, &m, &k, &t);
int o = n + m;
g.init(o + 2, INF);
int a, b;
for (int j(0), _b(k); j < _b; ++j) {
scanf("%d%d", &a, &b);
--a;
--b;
g.add(a, n + b, 1);
}
int f = 0;
for (int i(0), _b(o); i < _b; ++i) f += deg[i] % t != 0;
printf("%d\n", f);
for (int i(0), _b(n); i < _b; ++i) g.add(o, i, 0);
for (int i(n), _b(o); i < _b; ++i) g.add(i, o + 1, 0);
for (; t; --t) {
for (int i(0), _b(o); i < _b; ++i)
g.E[2 * (k + i)].cap = (deg[i] + t - 1) / t;
g.max_flow(o, o + 1);
for (int j(0), _b(2 * k); j < _b; ++j)
if (g.E[j].f) {
g.E[j].phase = t;
--deg[g.E[j].b];
}
}
for (int j(0), _b(k); j < _b; ++j) printf("%d ", g.E[2 * j].phase);
printf("\n");
}
|
#include <bits/stdc++.h>
const int maxn = 500;
const int maxm = 100000;
const int INF = 1 << 30;
using namespace std;
struct ZKW_flow {
int src, sink, e, n;
int first[maxn];
int cap[maxm], cost[maxm], v[maxm], next[maxm];
void init() {
e = 0;
memset(first, -1, sizeof(first));
}
void add_edge(int a, int b, int cc, int ww) {
cap[e] = cc;
cost[e] = ww;
v[e] = b;
next[e] = first[a];
first[a] = e++;
cap[e] = 0;
cost[e] = -ww;
v[e] = a;
next[e] = first[b];
first[b] = e++;
}
int d[maxn];
void spfa() {
for (int i = 1; i <= n; i++) d[i] = INF;
priority_queue<pair<int, int> > q;
d[src] = 0;
q.push(make_pair(0, src));
while (!q.empty()) {
int u = q.top().second, dd = -q.top().first;
q.pop();
if (d[u] != dd) continue;
for (int i = first[u]; i != -1; i = next[i]) {
if (cap[i] && d[v[i]] > dd + cost[i]) {
d[v[i]] = dd + cost[i];
q.push(make_pair(-d[v[i]], v[i]));
}
}
}
for (int i = 1; i <= n; i++) d[i] = d[sink] - d[i];
}
int Mincost, Maxflow;
bool used[maxn];
int add_flow(int u, int flow) {
if (u == sink) {
Maxflow += flow;
Mincost += d[src] * flow;
return flow;
}
used[u] = true;
int now = flow;
for (int i = first[u]; i != -1; i = next[i]) {
int &vv = v[i];
if (cap[i] && !used[vv] && d[u] == d[vv] + cost[i]) {
int tmp = add_flow(vv, min(now, cap[i]));
cap[i] -= tmp;
cap[i ^ 1] += tmp;
now -= tmp;
if (!now) break;
}
}
return flow - now;
}
bool modify_label() {
int dd = INF;
for (int u = 1; u <= n; u++)
if (used[u])
for (int i = first[u]; i != -1; i = next[i]) {
int &vv = v[i];
if (cap[i] && !used[vv]) dd = min(dd, d[vv] + cost[i] - d[u]);
}
if (dd == INF) return false;
for (int i = 1; i <= n; i++)
if (used[i]) d[i] += dd;
return true;
}
int min_cost_flow(int ss, int tt, int nn) {
src = ss, sink = tt, n = nn;
Mincost = Maxflow = 0;
spfa();
while (1) {
while (1) {
for (int i = 1; i <= n; i++) used[i] = 0;
if (!add_flow(src, INF)) break;
}
if (!modify_label()) break;
}
return Mincost;
}
} g;
int dx[210], dy[210];
int px[5010], py[5010];
int res[5010];
int main() {
int n, m, k, t, ans = 0;
scanf("%d%d%d%d", &n, &m, &k, &t);
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
dx[a]++, dy[b]++;
px[i] = a, py[i] = b;
}
for (int i = 1; i <= n; i++) ans += !!(dx[i] % t);
for (int i = 1; i <= m; i++) ans += !!(dy[i] % t);
printf("%d\n", ans);
for (int s = t; s > 0; s--) {
g.init();
int S = n + m + 1, T = S + 1;
for (int i = 0; i < k; i++) {
if (!res[i]) g.add_edge(px[i], py[i] + n, 1, 0);
}
for (int i = 1; i <= n; i++) {
g.add_edge(S, i, dx[i] / s, 0);
if (dx[i] % s) g.add_edge(S, i, 1, 1);
}
for (int i = 1; i <= m; i++) {
g.add_edge(n + i, T, dy[i] / s, 0);
if (dy[i] % s) g.add_edge(n + i, T, 1, 1);
}
g.min_cost_flow(S, T, T);
for (int i = 0, j = 0; i < k; i++) {
if (!res[i]) {
if (!g.cap[j]) {
res[i] = s;
dx[px[i]]--, dy[py[i]]--;
}
j += 2;
}
}
}
for (int i = 0; i < k; i++) printf("%d ", res[i]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.