text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int f[9][310][310], g[310][310], h[310][310];
int main() {
memset(f, -0x3f, sizeof(f));
memset(g, -0x3f, sizeof(g));
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, c1, c2;
scanf("%d%d%d%d", &u, &v, &c1, &c2);
f[0][u][v] = c1;
f[0][v][u] = c2;
}
for (int i = 1; i <= n; i++) f[0][i][i] = 0, g[i][i] = 0;
for (int i = 1; i <= 8; i++)
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++)
for (int k = 1; k <= n; k++) {
f[i][j][k] = std::max(f[i][j][k], f[i - 1][j][l] + f[i - 1][l][k]);
}
bool flag = 0;
int ans = 0;
for (int i = 8; i >= 0; i--) {
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) h[j][l] = g[j][l];
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++)
for (int k = 1; k <= n; k++) {
g[j][k] = std::max(g[j][k], h[j][l] + f[i][l][k]);
}
bool ok = 0;
for (int j = 1; j <= n; j++)
if (g[j][j] > 0) {
ok = 1;
break;
}
if (ok) {
flag = 1;
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) g[j][l] = h[j][l];
} else
ans += 1 << i;
}
if (!flag)
puts("0");
else
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = -100000000000LL;
struct Matrix {
int r, c;
vector<vector<long long> > mat;
Matrix(int rr, int cc)
: r(rr),
c(cc),
mat(vector<vector<long long> >(r, vector<long long>(c, 0))) {}
Matrix(vector<vector<long long> > vec)
: r(vec.size()), c(vec[0].size()), mat(vec) {}
Matrix identity(int n) {
Matrix I(n, n);
for (int i = 0; i < n; i++) I.mat[i][i] = 1;
return I;
}
bool awesome() {
for (int i = 0; i < r; i++)
if (mat[i][i] > 0) return true;
return false;
}
Matrix operator*(Matrix M) {
if (c != M.r) {
cout << "Not multiplicable\n" << endl;
exit(0);
}
Matrix res(M.r, M.c);
for (int i = 0; i < r; i++) {
for (int j = 0; j < M.c; j++) {
long long mcost = INF;
for (int k = 0; k < c; k++) {
mcost = max(mcost, mat[i][k] + M.mat[k][j]);
}
res.mat[i][j] = mcost;
}
}
return res;
}
Matrix operator^(int n) {
Matrix A = *this, B = identity(r);
while (n) {
if (n & 1) B = B * A;
A = A * A;
n >>= 1;
}
return B;
}
void _print() {
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) printf("%I64d ", mat[i][j]);
printf("\n");
}
return;
}
};
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
Matrix cost(n, n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j) cost.mat[i][j] = INF;
Matrix cur(cost);
for (int i = 0; i < m; i++) {
int u, v, x, y;
cin >> u >> v >> x >> y;
--u;
--v;
cost.mat[u][v] = x;
cost.mat[v][u] = y;
}
vector<Matrix> edges_2_k(10, Matrix(n, n));
edges_2_k[0] = cost;
for (int i = 1; i < 10; i++) {
edges_2_k[i] = edges_2_k[i - 1] * edges_2_k[i - 1];
}
if (!edges_2_k[9].awesome()) {
cout << "0" << endl;
return 0;
}
int ans = 1;
for (int i = 8; i >= 0; i--) {
Matrix new_cur = cur * edges_2_k[i];
if (!new_cur.awesome()) {
ans += (1 << i);
cur = new_cur;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 302;
int d[20][N][N], la[N][N], tmp[N][N];
int l, ans, n, m;
void matcpy(int a[N][N], const int b[N][N]) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) a[i][j] = b[i][j];
}
void mul(int c[N][N], const int a[N][N], const int b[N][N]) {
int i, j, k;
for (i = 1; i <= n; ++i) fill(c[i] + 1, c[i] + n + 1, -(1 << 25));
for (k = 1; k <= n; ++k)
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) c[i][j] = max(c[i][j], a[i][k] + b[k][j]);
}
bool check(const int a[N][N]) {
for (int i = 1; i <= n; ++i)
if (a[i][i] > 0) return 1;
matcpy(la, a);
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fill(d[0][i] + 1, d[0][i] + n + 1, -(1 << 25));
for (int s, t, x, y, i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &s, &t, &x, &y);
d[0][s][t] = max(d[0][s][t], x);
d[0][t][s] = max(d[0][t][s], y);
}
for (int i = 1; i <= n; ++i) d[0][i][i] = 0;
matcpy(tmp, d[0]);
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
tmp[i][j] = max(tmp[i][j], tmp[i][k] + tmp[k][j]);
if (!check(tmp)) {
printf("0\n");
return 0;
}
matcpy(la, d[0]);
l = 0;
for (int i = 1;; ++i) {
mul(d[i], d[i - 1], d[i - 1]);
if (check(d[i]))
break;
else
l = i;
}
ans = (1 << l);
for (int j = l - 1; j >= 0; --j) {
mul(tmp, la, d[j]);
if (!check(tmp)) ans += (1 << j);
}
printf("%d\n", ans + 1);
return 0;
}
|
#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 mod = 1000000007;
struct Matrix {
int num[310][310];
int n, m;
Matrix() {
for (int i = 0; i < 310; i++) {
for (int j = 0; j < 310; j++) {
num[i][j] = -99999999;
}
}
}
Matrix(int _n, int _m) {
n = _n;
m = _m;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
num[i][j] = -99999999;
}
}
}
Matrix operator+(const Matrix &B) const {
Matrix C(n, m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
C.num[i][j] = num[i][j] + B.num[i][j];
if (C.num[i][j] >= mod) C.num[i][j] %= mod;
}
}
return C;
}
Matrix operator*(const Matrix &B) const {
Matrix C(n, B.m);
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= m; k++) {
for (int j = 1; j <= B.m; j++) {
C.num[i][j] = max(C.num[i][j], num[i][k] + B.num[k][j]);
}
}
}
return C;
}
friend Matrix operator^(const Matrix &A, const int &k) {
int kk = k;
Matrix tp = A;
Matrix C(A.n, A.m);
for (int i = 1; i <= C.n; i++) C.num[i][i] = 0;
while (kk > 0) {
if (kk & 1) C = C * tp;
tp = tp * tp;
kk >>= 1;
}
return C;
}
void show() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d", num[i][j]);
if (j == m)
printf("\n");
else
printf(" ");
}
}
}
} I;
Matrix Sum(Matrix A, int k) {
if (k == 1)
return A;
else if (k & 1)
return Sum(A, k - 1) + (A ^ k);
else
return Sum(A, k >> 1) * ((A ^ (k >> 1)) + I);
}
void initI(int n) {
I.n = I.n = n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
I.num[i][j] = (i == j);
}
}
}
Matrix save[10];
int main() {
int i, j;
int n, m;
int a, b, c1, c2;
while (scanf("%d%d", &n, &m) != EOF) {
Matrix res(n, n);
for (i = 1; i <= n; i++) res.num[i][i] = 0;
Matrix temp = res;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &a, &b, &c1, &c2);
res.num[a][b] = c1;
res.num[b][a] = c2;
}
save[0] = res;
for (i = 1; i < 10; i++) {
save[i] = save[i - 1] * save[i - 1];
}
int ff = 0;
for (i = 1; i <= n; i++) {
if (save[9].num[i][i] > 0) ff = 1;
}
if (!ff) {
puts("0");
continue;
}
int ans = 0;
for (i = 9; i >= 0; i--) {
ff = 0;
Matrix tt = temp * save[i];
for (j = 1; j <= n; j++) {
if (tt.num[j][j] > 0) ff = 1;
}
if (!ff) {
temp = tt;
ans += (1 << (i));
}
}
printf("%d\n", ans + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int g[10][300][300];
int w[300][300], e[300][300];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[0][i][j] = int(i != j) * 1e9;
for (int i = 0; i < m; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a--;
b--;
g[0][a][b] = -c;
g[0][b][a] = -d;
}
int ok2 = 0, pos = 0;
for (int i = 1; (1 << (i - 1)) <= n; i++) {
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++) g[i][a][b] = int(a != b) * 1e9;
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++)
for (int c = 0; c < n; c++)
g[i][a][c] = min(g[i][a][c], g[i - 1][a][b] + g[i - 1][b][c]);
int ok = 0;
for (int a = 0; a < n && !ok; a++)
if (g[i][a][a] < 0) {
ok = 1;
break;
}
if (ok) {
pos = i - 1;
ok2 = 1;
break;
}
}
if (!ok2) {
printf("0\n");
return 0;
}
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++) w[a][b] = g[pos][a][b];
int cur = 1 << pos, ans = n;
for (int i = pos; i >= 0; i--) {
int ok = 0;
for (int a = 0; a < n && !ok; a++)
for (int b = 0; b < n && !ok; b++)
if (w[a][b] + g[i][b][a] < 0) ok = 1;
if (!ok) {
cur += 1 << i;
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++) e[a][b] = w[a][b];
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++)
for (int c = 0; c < n; c++)
w[a][c] = min(w[a][c], e[a][b] + g[i][b][c]);
} else
ans = min(ans, cur + (1 << i));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
int n, m;
int mat[9][N][N];
int tmp[N][N];
int ret[N][N];
void checkmax(int &t, int x) { t = x > t ? x : t; }
int main() {
memset(mat, 200, sizeof(mat));
scanf("%d%d", &n, &m);
for (int x, y, i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
scanf("%d%d", &mat[0][x - 1][y - 1], &mat[0][y - 1][x - 1]);
}
for (int i = 0; i < n; i++) mat[0][i][i] = 0;
for (int q = 1; q < 9; q++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
checkmax(mat[q][i][j], mat[q - 1][i][k] + mat[q - 1][k][j]);
int ans = 0;
memset(ret, 200, sizeof(ret));
for (int i = 0; i < n; ++i) ret[i][i] = 0;
for (int q = 8; q >= 0; q--) {
memset(tmp, 200, sizeof(tmp));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
checkmax(tmp[i][j], ret[i][k] + mat[q][k][j]);
int tag = 0;
for (int i = 0; i < n; i++)
if (tmp[i][i] > 0) {
tag = 1;
break;
}
if (!tag) {
memcpy(ret, tmp, sizeof(tmp));
ans += 1 << q;
}
}
if (ans + 1 > n)
puts("0");
else
printf("%d\n", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD7 = (int)1e9 + 7;
template <class T1, class T2>
int upmin(T1 &x, T2 v) {
if (x > v) {
x = v;
return 1;
}
return 0;
}
template <class T1, class T2>
int upmax(T1 &x, T2 v) {
if (x < v) {
x = v;
return 1;
}
return 0;
}
int N, M;
vector<tuple<int, int, int, int> > C;
void init() {
cin >> N >> M;
C = vector<tuple<int, int, int, int> >(M);
for (int i = 0; i < M; ++i) {
int x, y, cxy, cyx;
cin >> x >> y >> cxy >> cyx;
C[i] = make_tuple(x - 1, y - 1, cxy, cyx);
}
}
int maxp;
vector<vector<vector<int> > > dbl;
vector<vector<vector<int> > > pdbl;
vector<vector<int> > I;
vector<vector<int> > mat_mul(vector<vector<int> > a, vector<vector<int> > b) {
vector<vector<int> > res = I;
for (int i = 0; i < a.size(); ++i)
for (int j = 0; j < b.size(); ++j)
for (int k = 0; k < b[0].size(); ++k) upmax(res[i][k], a[i][j] + b[j][k]);
return res;
}
void preprocess() {
I = vector<vector<int> >(N, vector<int>(N, -INF));
for (int i = 0; i < N; ++i) I[i][i] = 0;
maxp = 32 - __builtin_clz(N) - 1;
dbl = pdbl = vector<vector<vector<int> > >(
maxp + 1, vector<vector<int> >(N, vector<int>(N)));
dbl[0] = I;
for (int i = 0; i < M; ++i) {
int x, y, cxy, cyx;
tie(x, y, cxy, cyx) = C[i];
dbl[0][x][y] = cxy;
dbl[0][y][x] = cyx;
}
for (int i = 0; i < maxp; ++i) dbl[i + 1] = mat_mul(dbl[i], dbl[i]);
pdbl[0] = I;
for (int i = 0; i < maxp; ++i) pdbl[i + 1] = mat_mul(pdbl[i], dbl[i]);
}
void solve() {
int ans = 0;
vector<vector<int> > pre = I;
for (int i = maxp; 0 <= i; --i) {
int ok = 0;
vector<vector<int> > cur = mat_mul(pre, pdbl[i]);
for (int j = 0; j < N; ++j) ok |= cur[j][j] > 0;
if (not ok) ans |= 1 << i, pre = mat_mul(pre, dbl[i]);
}
int ok = 0;
for (int i = 0; i < N; ++i) ok |= pre[i][i] > 0;
if (not ok)
cout << 0 << endl;
else
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
init();
preprocess();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
int N, M;
int F[305][305][12], G[305][305], G2[305][305];
void init() {
int i, j, l, x, y;
scanf("%d%d", &N, &M);
memset(F, 0xF0, sizeof(F));
for (i = 1; i <= M; i++) {
scanf("%d%d", &x, &y);
scanf("%d%d", &F[x][y][0], &F[y][x][0]);
}
}
inline void MAX(int &a, int b) {
if (a < b) a = b;
}
void work() {
int l, i, j, k, ans = 0;
memset(G, 0xF0, sizeof(G));
for (i = 1; i <= N; i++) G[i][i] = F[i][i][0] = 0;
for (l = 1; l <= 8; l++)
for (k = 1; k <= N; k++)
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++)
MAX(F[i][j][l], F[i][k][l - 1] + F[k][j][l - 1]);
for (l = 8; l >= 0; l--) {
memset(G2, 0xF0, sizeof(G2));
for (k = 1; k <= N; k++) {
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++) MAX(G2[i][j], G[i][k] + F[k][j][l]);
}
for (i = 1; i <= N; i++)
if (G2[i][i] > 0) break;
if (i <= N) continue;
memcpy(G, G2, sizeof(G));
ans += 1 << l;
}
cout << (ans >= N ? 0 : ans + 1) << endl;
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 310;
const int INF = 10000000;
int N, M;
int mymax(int x, int y) { return x > y ? x : y; }
struct martix {
int a[SIZE][SIZE];
bool ok() {
for (int i = 1; i <= N; i++)
if (a[i][i] > 0) return true;
return false;
}
void init() {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) a[i][j] = -INF;
for (int i = 1; i <= N; i++) a[i][i] = 0;
}
martix operator*(martix A) {
martix B;
B.init();
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++)
B.a[i][j] = mymax(B.a[i][j], a[i][k] + A.a[k][j]);
return B;
}
} p[10], now, nxt;
void Read() {
scanf("%d%d", &N, &M);
p[0].init();
for (int i = 1; i <= M; i++) {
int u, v, c1, c2;
scanf("%d%d%d%d", &u, &v, &c1, &c2);
p[0].a[u][v] = mymax(p[0].a[u][v], c1);
p[0].a[v][u] = mymax(p[0].a[v][u], c2);
}
}
int Solve() {
for (int i = 1; i <= 9; i++) p[i] = p[i - 1] * p[i - 1];
if (!p[9].ok()) return 0;
int ans = 0;
now.init();
for (int i = 9; i >= 0; i--) {
nxt = now * p[i];
if (!nxt.ok()) {
now = nxt;
ans += (1 << i);
}
}
return ans + 1;
}
int main() {
Read();
printf("%d\n", Solve());
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
using namespace std;
namespace t {
template <typename T>
inline const T gcd(T __m, T __n) {
while (__n != 0) {
T __t = __m % __n;
__m = __n;
__n = __t;
}
return __m;
}
template <typename T>
inline const T max(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline const T min(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline const T abs(const T &a) {
return a > 0 ? a : -a;
}
template <typename T>
inline void in(T &x) {
register T res = 0;
register int neg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = -1;
}
}
for (; isdigit(c); c = getchar()) {
res = res * 10 + c - '0';
}
x = res * neg;
}
inline int read() {
register int res = 0, neg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = -1;
}
}
for (; isdigit(c); c = getchar()) {
res = res * 10 + c - '0';
}
return res * neg;
}
} // namespace t
const int maxn = 310, maxk = 10, inf = (int)1e9;
int d[maxk][maxn][maxn], f[maxk][maxn][maxn];
int n, m, ans = 1;
int main() {
t::in(n), t::in(m);
for (int i = 0; i <= 9; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
d[i][j][k] = f[i][j][k] = -inf;
}
}
}
for (int i = 1; i <= n; ++i) d[0][i][i] = f[9][i][i] = 0;
for (int i = 1, u, v, w, q; i <= m; ++i) {
t::in(u), t::in(v), t::in(w), t::in(q);
d[0][u][v] = w, d[0][v][u] = q;
}
for (int t = 1; t <= 8; ++t) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
d[t][i][j] = t::max(d[t][i][j], d[t - 1][i][k] + d[t - 1][k][j]);
}
}
}
}
for (int t = 8, flag = 9; t >= 0; --t) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
f[t][i][j] = t::max(f[t][i][j], f[flag][i][k] + d[t][k][j]);
}
}
}
int has = -1;
for (int i = 1; i <= n; ++i) {
if (f[t][i][i] > 0) {
has = t;
break;
}
}
if (has == -1) {
flag = t, ans += (1 << t);
}
}
if (ans <= n) {
printf("%d\n", ans);
} else {
puts("0");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[22][330][330], ans[330][330], temp[330][330];
int n, m;
bool judge(int a[][330]) {
for (int i = 1; i <= n; ++i)
if (a[i][i] > 0) return true;
return false;
}
void floyd(int a[][330], int b[][330], int c[][330]) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) a[i][j] = -1e9;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (a[i][j] < b[i][k] + c[k][j]) a[i][j] = b[i][k] + c[k][j];
}
int main() {
while (~scanf("%d %d", &n, &m)) {
int a, b, c1, c2;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i == j)
dp[0][i][j] = 0;
else
dp[0][i][j] = -1e9;
for (int i = 0; i < m; ++i) {
scanf("%d %d %d %d", &a, &b, &c1, &c2);
dp[0][a][b] = c1;
dp[0][b][a] = c2;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) ans[i][j] = dp[0][i][j];
for (int i = 0; i < 9; ++i) floyd(dp[i + 1], dp[i], dp[i]);
if (!judge(dp[9])) {
cout << 0 << endl;
continue;
}
int num = 1;
for (int i = 9; i >= 0; i--) {
floyd(temp, dp[i], ans);
if (!judge(temp)) {
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k) ans[j][k] = temp[j][k];
num += (1 << i);
}
}
cout << num + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int N = 300 + 10;
const int M = 9;
int n, m;
struct Tmat {
int a[N][N];
void ReSet() {
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (n); j++) a[i][j] = -inf;
a[i][i] = 0;
}
}
Tmat() { ReSet(); }
Tmat operator*(const Tmat &b) const {
Tmat c;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
for (int k = (1); k <= (n); k++)
if (a[i][k] != -inf && b.a[k][j] != -inf)
c.a[i][j] = max(c.a[i][j], a[i][k] + b.a[k][j]);
return c;
}
bool PostiveCircle() {
for (int i = (1); i <= (n); i++)
if (a[i][i] > 0) return 1;
return 0;
}
} pw2[M + 1];
int main() {
cin >> n >> m;
pw2[0].ReSet();
for (int i = (1); i <= (m); i++) {
int x, y, c0, c1;
scanf("%d%d%d%d", &x, &y, &c0, &c1);
pw2[0].a[x][y] = c0;
pw2[0].a[y][x] = c1;
}
for (int i = (1); i <= (M); i++) pw2[i] = pw2[i - 1] * pw2[i - 1];
if (!pw2[M].PostiveCircle()) return puts("0"), 0;
int ans = 0;
Tmat now, next;
for (int i = (M); i >= (0); i--) {
next = now * pw2[i];
if (!next.PostiveCircle()) {
now = next;
ans += 1 << i;
}
}
cout << ans + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
int f[10][310][310], ans[2][310][310], n;
bool ok(int x) {
int k, now = 0, i, j, p;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) ans[0][i][j] = i == j ? 0 : -oo;
for (k = 0; (1 << k) <= x; k++)
if (x & (1 << k)) {
now ^= 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) ans[now][i][j] = -oo;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (p = 1; p <= n; p++)
ans[now][i][j] =
max(ans[now][i][j], ans[now ^ 1][i][p] + f[k][p][j]);
}
for (i = 1; i <= n; i++)
if (ans[now][i][i] > 0) return 1;
return 0;
}
int main() {
int i, j, k, m, p, q, x, y, z, w, l, r, mid;
scanf("%d%d", &n, &m);
for (k = 0; (1 << k) <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) f[k][i][j] = i == j ? 0 : -oo;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &x, &y, &z, &w);
f[0][x][y] = z;
f[0][y][x] = w;
}
for (k = 1; (1 << k) <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (x = 1; x <= n; x++)
f[k][i][j] = max(f[k][i][j], f[k - 1][i][x] + f[k - 1][x][j]);
l = 2;
r = n + 1;
while (l < r) {
mid = (l + r) / 2;
if (ok(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l % (n + 1));
}
|
#include <bits/stdc++.h>
inline int max(int x, int y) { return x > y ? x : y; }
int V, E, k, l, r, o, u, v, w, x, G[8 + 1][300 + 1][300 + 1],
F[2][300 + 1][300 + 1];
int main() {
scanf("%d %d", &V, &E);
for (k = 0; (1 << k) <= V; ++k)
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v) G[k][u][v] = -0x3F3F3F3F;
while (E--) scanf("%d %d", &u, &v), scanf("%d %d", &G[0][u][v], &G[0][v][u]);
for (k = 1; (1 << k) <= V; ++k) {
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v) G[k][u][v] = G[k - 1][u][v];
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v)
for (x = 1; x <= V; ++x)
G[k][u][v] = max(G[k][u][v], G[k - 1][u][x] + G[k - 1][x][v]);
}
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v) F[0][u][v] = u == v ? 0 : -0x3F3F3F3F;
r = 0;
for (--k; k >= 0; --k) {
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v) F[1][u][v] = -0x3F3F3F3F;
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v)
for (x = 1; x <= V; ++x)
F[1][u][v] = max(F[1][u][v], F[0][u][x] + G[k][x][v]);
for (u = 1; u <= V && F[1][u][u] <= 0; ++u)
;
if (u <= V) {
r = w + (1 << k);
continue;
}
w += 1 << k;
for (u = 1; u <= V; ++u)
for (v = 1; v <= V; ++v) F[0][u][v] = F[1][u][v];
}
printf("%d\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300;
const int INF = 1 << 29;
int a[9][N][N], b[N][N], c[N][N];
void multiply(int a[N][N], int b[N][N], int c[N][N], int n) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
c[i][j] = -INF;
for (int k = 0; k < n; ++k) {
if (a[i][k] != -INF && b[k][j] != -INF) {
c[i][j] = max(c[i][j], a[i][k] + b[k][j]);
}
}
}
}
}
void init(int a[N][N], int n) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = -INF;
}
a[i][i] = 0;
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
init(a[0], n);
while (m--) {
int x, y, u, v;
scanf("%d %d %d %d", &x, &y, &u, &v);
--x;
--y;
a[0][x][y] = u;
a[0][y][x] = v;
}
for (int k = 1; k <= 8; ++k) {
multiply(a[k - 1], a[k - 1], a[k], n);
}
int ret = 0;
init(b, n);
for (int k = 8; k >= 0; --k) {
multiply(b, a[k], c, n);
bool found = false;
for (int i = 0; i < n; ++i) {
if (c[i][i] > 0) {
found = true;
break;
}
}
if (!found) {
ret += 1 << k;
memcpy(b, c, sizeof(b));
}
}
ret += 1;
if (ret > n)
puts("0");
else
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300 + 5;
int f[15][MAXN][MAXN], tmp[MAXN][MAXN], last[MAXN][MAXN];
int n, m, ans;
int main() {
memset(last, -0x3f3f3f3f, sizeof(last));
memset(f, -0x3f3f3f3f, sizeof(f));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
scanf("%d%d", &f[0][u][v], &f[0][v][u]);
}
for (int i = 1; i <= n; i++) {
last[i][i] = 0;
f[0][i][i] = 0;
}
for (int s = 1; s <= 10; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
f[s][i][j] = max(f[s][i][j], f[s - 1][i][k] + f[s - 1][k][j]);
}
}
}
}
for (int s = 10; s >= 0; s--) {
memset(tmp, -0x3f3f3f3f, sizeof(tmp));
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
tmp[i][j] = max(tmp[i][j], last[i][k] + f[s][k][j]);
}
}
}
bool flag = false;
for (int i = 1; i <= n; i++) {
if (tmp[i][i] > 0) {
flag = true;
break;
}
}
if (flag) {
continue;
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
last[i][j] = tmp[i][j];
}
}
ans += 1 << s;
}
}
printf("%d\n", (ans >= n ? 0 : ans + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305, lgN = 11;
typedef long long matrix[N][N];
matrix I, S, C, T, R, D[lgN];
int n;
void mult(matrix A, matrix B, matrix R) {
for (int x = 1; x <= n; ++x)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) R[i][j] = max(R[i][j], A[i][x] + B[x][j]);
}
int solve() {
int m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) S[i][j] = I[i][j] = (-(~0ULL >> 4)) * (i != j);
memcpy(R, I, sizeof R);
for (int i = 1, a, b, c, d; i <= m; ++i) {
cin >> a >> b >> c >> d;
S[a][b] = c;
S[b][a] = d;
}
memcpy(D[0], S, sizeof D[0]);
for (int i = 1; i < lgN; ++i) {
memcpy(D[i], I, sizeof I);
mult(D[i - 1], D[i - 1], D[i]);
}
int res(0);
for (int i = lgN - 1; i >= 0; --i) {
memcpy(T, I, sizeof T);
mult(R, D[i], T);
bool fnd = false;
for (int j = 1; !fnd && j <= n; ++j)
if (T[j][j] > 0) fnd = true;
if (!fnd) {
res += 1 << i;
memcpy(R, T, sizeof R);
}
}
if (res > n + 10)
cout << 0 << endl;
else
cout << res + 1 << endl;
return 0;
}
int main() { return solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305, oo = 1e8, LOG = 10;
int n, m, g[N][N];
struct Matrix {
vector<vector<int>> mat;
Matrix() {
mat.assign(n + 5, vector<int>(n + 5, -oo));
for (int i = 1; i <= n; ++i) mat[i][i] = 0;
}
} F[LOG];
Matrix operator+(const Matrix &a, const Matrix &b) {
Matrix res;
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
res.mat[i][j] = max(res.mat[i][j], a.mat[i][k] + b.mat[k][j]);
}
}
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) g[i][j] = -oo;
}
for (int i = 0; i < LOG; ++i) F[i] = Matrix();
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
cin >> g[u][v] >> g[v][u];
F[0].mat[u][v] = g[u][v];
F[0].mat[v][u] = g[v][u];
}
for (int i = 1; i <= 9; ++i) F[i] = F[i - 1] + F[i - 1];
int res = 0;
Matrix cur;
for (int i = 9; i >= 0; --i) {
Matrix tmp = cur + F[i];
bool f = false;
for (int j = 1; j <= n; ++j)
if (tmp.mat[j][j] > 0) f = true;
if (!f) {
if (i == 9) {
cout << 0 << endl;
return 0;
}
cur = tmp, res += (1 << i);
}
}
cout << res + 1 << endl;
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int res = 0, s = 1;
char ch;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') s = -1, ch = getchar();
for (; ch >= '0' && ch <= '9'; ch = getchar()) res = res * 10 + ch - 48;
return res * s;
}
int n, m, dis[10][305][305], now[305][305], res[305][305];
int main() {
n = gi(), m = gi();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dis[0][i][j] = -0x3f3f3f3f;
for (int i = 1, x, y, a, b; i <= m; ++i) {
x = gi(), y = gi(), a = gi(), b = gi();
dis[0][x][y] = a, dis[0][y][x] = b;
}
for (int i = 1; i <= n; ++i) dis[0][i][i] = 0;
for (int d = 1; d <= 9; ++d) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dis[d][i][j] = -0x3f3f3f3f;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[d][i][j] = (dis[d][i][j] >= dis[d - 1][i][k] + dis[d - 1][k][j]
? dis[d][i][j]
: dis[d - 1][i][k] + dis[d - 1][k][j]);
}
int ans = 1, flag = 0;
for (int i = 1; (!flag) && i <= n; ++i)
if (dis[9][i][i] > 0) flag = 1;
if (!flag) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) now[i][j] = dis[0][i][j];
for (int d = 9; d >= 0; --d) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) res[i][j] = -0x3f3f3f3f;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
res[i][j] = (res[i][j] >= now[i][k] + dis[d][k][j]
? res[i][j]
: now[i][k] + dis[d][k][j]);
flag = 0;
for (int i = 1; i <= n && !flag; ++i)
if (res[i][i] > 0) flag = 1;
if (!flag) {
ans += (1 << d);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) now[i][j] = res[i][j];
}
}
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, v, w, f[10][301][301], ans[2][301][301];
bool b;
bool cal(int u) {
b = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans[0][i][j] = i == j ? 0 : -999999999;
for (int k = 0; (1 << k) <= u; k++)
if (u & (1 << k)) {
b ^= 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans[b][i][j] = -999999999;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int z = 1; z <= n; z++)
ans[b][i][j] = max(ans[b][i][j], ans[b ^ 1][i][z] + f[k][z][j]);
}
for (int i = 1; i <= n; i++)
if (ans[b][i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int k = 0; (1 << k) <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[k][i][j] = i == j ? 0 : -999999999;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &x, &y, &v, &w);
f[0][x][y] = v;
f[0][y][x] = w;
}
for (int k = 1; (1 << k) <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int z = 1; z <= n; z++)
f[k][i][j] = max(f[k][i][j], f[k - 1][i][z] + f[k - 1][z][j]);
int l = 2, r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (cal(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l % (n + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
int ele[320][320];
};
int n, m;
Matrix orig, dp[16], tmp, tmp2, res;
Matrix operator*(const Matrix &a, const Matrix &b) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
res.ele[i][j] = i == j ? 0 : -0x3FFFFFFF;
for (int k = 0; k < n; k++) {
if (a.ele[i][k] != -0x3FFFFFFF && b.ele[k][j] != -0x3FFFFFFF) {
res.ele[i][j] = max(res.ele[i][j], a.ele[i][k] + b.ele[k][j]);
}
}
}
}
return res;
}
int my_log2(int num) {
int ans = 0;
while (num) {
ans++;
num >>= 1;
}
return ans - 1;
}
bool test(const Matrix &a) {
for (int i = 0; i < n; i++) {
if (a.ele[i][i] > 0) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
orig.ele[i][j] = i == j ? 0 : -0x3FFFFFFF;
}
}
for (int i = 0; i < m; i++) {
int a, b, x, y;
cin >> a >> b >> x >> y;
orig.ele[--a][--b] = x;
orig.ele[b][a] = y;
}
dp[0] = orig;
for (int i = 1; (1 << i) <= n; i++) dp[i] = dp[i - 1] * dp[i - 1];
tmp = orig;
int ans = 1;
for (int i = my_log2(n); i >= 0; i--) {
tmp2 = tmp * dp[i];
if (!test(tmp2)) {
tmp = tmp2;
ans += 1 << i;
}
}
tmp = tmp * orig;
if (test(tmp))
cout << ++ans << endl;
else
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 302;
const int INF = 999999999;
int temp[maxn][maxn], now[maxn][maxn];
int dp[11][maxn][maxn];
int n, m;
void init() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[0][i][j] = -INF;
if (i == j) dp[0][i][i] = 0;
}
}
}
void go(int a[][maxn], int b[][maxn], int c[][maxn]) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) {
a[i][j] = -INF;
if (i == j) a[i][j] = 0;
}
for (int k = 0; k <= n; k++)
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) a[i][j] = max(b[i][k] + c[k][j], a[i][j]);
}
int check(int a[][maxn]) {
for (int i = 0; i <= n; i++)
if (a[i][i] > 0) return 1;
return 0;
}
int main() {
while (cin >> n >> m) {
init();
for (int i = 0, a, b, c, d; i < m; i++) {
cin >> a >> b >> c >> d;
dp[0][a][b] = c;
dp[0][b][a] = d;
}
for (int i = 1; i <= 9; i++) go(dp[i], dp[i - 1], dp[i - 1]);
if (check(dp[9])) {
} else {
cout << "0\n";
continue;
}
memcpy(temp, dp[0], sizeof(dp[0]));
int ans = 2;
for (int i = 9; i >= 0; i--) {
go(now, dp[i], temp);
if (!check(now)) {
memcpy(temp, now, sizeof(now));
ans += (1 << i);
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 410;
int n, m, c1, c2;
int d[30][MAXN][MAXN], d2[MAXN][MAXN], d3[MAXN][MAXN];
int x, y;
int main() {
scanf("%d %d", &n, &m);
memset(d, 63, sizeof(d));
memset(d2, 63, sizeof(d2));
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &x, &y, &c1, &c2);
x--, y--;
c1 = -c1, c2 = -c2;
d[0][x][y] = c1, d[0][y][x] = c2;
}
for (int i = 0; i < n; i++) d[0][i][i] = 0;
int s = 0;
for (s = 0; (1 << s) <= n; s++) {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (d[s + 1][i][j] > d[s][i][k] + d[s][k][j])
d[s + 1][i][j] = d[s][i][k] + d[s][k][j];
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) d2[i][i] = 0;
for (s--; s >= 0; s--) {
memset(d3, 63, sizeof(d3));
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (d3[i][j] > d2[i][k] + d[s][k][j])
d3[i][j] = d2[i][k] + d[s][k][j];
}
}
}
bool bingo = false;
for (int i = 0; i < n; i++) {
if (d3[i][i] < 0) {
bingo = true;
break;
}
}
if (!bingo) {
ans = ans | (1 << s);
memcpy(d2, d3, sizeof(d3));
}
}
if (ans >= n) {
printf("0\n");
} else {
printf("%d\n", ans + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
int a[310][310], sz;
inline Matrix(int _sz = 0) {
sz = _sz;
for (int i = 1; i <= sz; i++)
for (int j = 1; j <= sz; j++) a[i][j] = ((i == j) ? 0 : -1000000010);
}
inline Matrix operator*(Matrix &b) {
Matrix c(sz);
for (int i = 1; i <= sz; i++)
for (int j = 1; j <= sz; j++) {
c.a[i][j] = -1000000010;
for (int k = 1; k <= sz; k++)
c.a[i][j] = max(c.a[i][j], a[i][k] + b.a[k][j]);
}
return c;
}
};
int n, m, ans;
int main() {
cin >> n >> m;
Matrix w(n), p[11], t(n);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
cin >> w.a[x][y] >> w.a[y][x];
}
p[0] = w;
for (int i = 1; i <= 10; i++) p[i] = p[i - 1] * p[i - 1];
for (int i = 10; i >= 0; i--) {
Matrix temp = t * p[i];
bool flag = false;
for (int j = 1; j <= n; j++)
if (temp.a[j][j] > 0) {
flag = true;
break;
}
if (!flag) {
t = temp;
ans += (1 << i);
}
}
if (ans == 2047)
cout << 0 << "\n";
else
cout << ans + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Tmatrix {
int num[308][308];
void unit() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) num[i][j] = -3000000;
for (int i = 1; i <= n; i++) num[i][i] = 0;
}
Tmatrix operator*(Tmatrix &a) {
Tmatrix c;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
c.num[i][j] = -3000000;
for (int k = 1; k <= n; k++)
c.num[i][j] =
(c.num[i][j] > a.num[i][k] + num[k][j] ? c.num[i][j]
: a.num[i][k] + num[k][j]);
}
return c;
}
} tmp, ans, f[9];
struct Tprogram {
void open() {
freopen("", "r", stdin);
freopen("", "w", stdout);
}
void close() {
fclose(stdin);
fclose(stdout);
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
tmp.num[i][j] = -3000000;
else
tmp.num[i][j] = 0;
int x, y, z1, z2;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &x, &y, &z1, &z2);
tmp.num[x][y] = z1;
tmp.num[y][x] = z2;
}
}
void work() {
ans.unit();
f[0] = tmp;
for (int i = 1; i <= 8; i++) f[i] = f[i - 1] * f[i - 1];
int k = 0;
for (int i = 8; i >= 0; i--) {
tmp = ans * f[i];
for (int i = 1; i <= n; i++)
if (tmp.num[i][i] > 0) {
goto die;
}
ans = tmp;
k += 1 << i;
die:;
}
if (k + 1 > n)
printf("%d\n", 0);
else
printf("%d\n", k + 1);
}
} Program;
int main() {
Program.init();
Program.work();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const long long int N = 300 + 10, INF = 1e18, LOG = 15;
template <class T, int SZ>
struct Mat {
int n, m;
T mat[SZ][SZ];
Mat(int _n, int _m) {
n = _n;
m = _m;
Fill(-INF);
}
void Fill(T x) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == j)
mat[i][j] = 0;
else
mat[i][j] = x;
}
}
}
friend Mat operator+(const Mat &x, const Mat &y) {
assert(x.m == y.n);
Mat ans = Mat(x.n, y.m);
for (int i = 0; i < x.n; i++) {
for (int j = 0; j < y.m; j++) {
for (int k = 0; k < x.m; k++) {
ans.mat[i][j] = max(ans.mat[i][j], x.mat[i][k] + y.mat[k][j]);
}
}
}
return ans;
}
friend Mat operator^(Mat t, long long int x) {
assert(t.n == t.m);
Mat ans = Mat(t.n, t.m);
for (int i = 0; i < t.n; i++) ans.mat[i][i] = 1;
while (x != 0) {
if (x & 1) ans = ans * t;
x >>= 1;
t = t * t;
}
return ans;
}
};
int n, m, C[2][N * N], E[2][N * N];
vector<Mat<long long int, N>> dp;
int check(Mat<long long int, N> M) {
for (int i = 0; i < n; i++) {
if (M.mat[i][i] > 0) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (long long int i = 0; i < LOG; i++)
dp.push_back(Mat<long long int, N>(n, n));
for (int i = 1; i <= m; i++) {
int u, v, wi, wj;
scanf("%d%d%d%d", &u, &v, &wi, &wj);
u--, v--;
dp[0].mat[u][v] = wi, dp[0].mat[v][u] = wj;
}
for (long long int i = 1; i < LOG; i++) {
dp[i] = dp[i - 1] + dp[i - 1];
}
Mat<long long int, N> A(n, n), T(n, n);
int ans = 0, lst = -1;
for (int i = LOG - 1; i >= 0; i--) {
if (lst == -1)
T = dp[i], lst = 0;
else
T = A + dp[i];
if (!check(T)) {
A = T;
ans ^= (1 << i);
}
}
if (ans > n)
printf("0\n");
else
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18;
long long N, M, maxlog, ans;
vector<vector<long long> > idn, adj, aux, ret;
vector<vector<vector<long long> > > prep;
vector<vector<long long> > operator*(const vector<vector<long long> >& A,
const vector<vector<long long> >& B) {
vector<vector<long long> > C = idn;
for (long long i = 0; i < A.size(); i++) {
for (long long j = 0; j < B[0].size(); j++) {
for (long long k = 0; k < B.size(); k++) {
C[i][j] = max(C[i][j], A[i][k] + B[k][j]);
}
}
}
return C;
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> N >> M;
idn = vector<vector<long long> >(N, vector<long long>(N, -oo));
for (long long i = 0; i < N; i++) idn[i][i] = 0;
adj = idn;
while (M--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
--a, --b;
adj[a][b] = c;
adj[b][a] = d;
}
prep.push_back(adj);
for (maxlog = 1; (1 << maxlog) <= N; maxlog++) {
prep.push_back(prep.back() * prep.back());
}
ret = idn;
for (long long i = maxlog - 1; ~i; i--) {
bool can = true;
aux = ret * prep[i];
if (false) cerr << i << "-th diag values:" << '\n';
for (long long j = 0; j < N; j++) {
can &= aux[j][j] <= 0;
if (false) cerr << j << ": " << aux[j][j] << (j + 1 == N ? "\n" : " | ");
}
if (can) {
ans += (1 << i);
ret = aux;
}
}
ret = ret * adj;
bool can = true;
for (long long j = 0; j < N; j++) {
can &= ret[j][j] <= 0;
}
cout << (!can ? ++ans : !can) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct MP {
long long g[310][310];
} f[10], nil, tmp, c;
int n, m, x, y, z1, z2, ans;
void U(long long &x, long long y) { x = max(x, y); }
MP CC(MP &f1, MP &f2) {
MP res = nil;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) U(res.g[i][j], f1.g[i][k] + f2.g[k][j]);
U(res.g[i][j], min(f1.g[i][j], f2.g[i][j]));
}
return res;
}
bool pd(MP &t) {
for (int i = 1; i <= n; i++)
if (t.g[i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
memset(nil.g, -38, sizeof nil.g);
for (int i = 0; i < 10; i++) f[i] = nil;
for (; m--;) {
scanf("%d%d%d%d", &x, &y, &z1, &z2);
f[0].g[x][y] = z1;
f[0].g[y][x] = z2;
}
for (int i = 1; i < 10; i++) {
f[i] = CC(f[i - 1], f[i - 1]);
if (pd(f[i])) {
ans = 1 << i >> 1;
tmp = f[i - 1];
for (int j = i - 2; j >= 0; j--) {
c = CC(tmp, f[j]);
if (!pd(c)) {
tmp = c;
ans += 1 << j;
}
}
return 0 * printf("%d", ans + 1);
}
}
printf("0");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[21][310][310], dp[21][310][310], up;
inline int getint() {
int w = 0, q = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 1, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? -w : w;
}
void init() {
cin >> n >> m;
up = (int)floor(log2((long double)n));
for (int i = 0; i <= up; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) dp[i][j][k] = -1 * 0x3f3f3f3f;
for (int s = 0; s <= up; s++)
for (int i = 1; i <= n; i++) dp[s][i][i] = 0;
for (int i = 1; i <= m; i++) {
int u = getint(), v = getint();
dp[0][u][v] = getint(), dp[0][v][u] = getint();
}
}
void make_dp() {
for (int s = 1; s <= up; s++)
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++) {
if (dp[s - 1][i][k] == -0x3f3f3f3f) continue;
for (int j = 1; j <= n; j++)
dp[s][i][j] = max(dp[s][i][j], dp[s - 1][i][k] + dp[s - 1][k][j]);
}
}
bool check(int x) {
for (int i = 0; i <= up; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) a[i][j][k] = -1 * 0x3f3f3f3f;
for (int i = 1; i <= n; i++) a[0][i][i] = 0;
int p = 0;
for (int s = 0; s <= up; s++) {
if (((x >> s) & 1) == 0) continue;
p++;
for (int i = 1; i <= n; i++) a[p][i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
a[p][i][j] = max(a[p][i][j], a[p - 1][i][k] + dp[s][k][j]);
}
for (int i = 1; i <= n; i++)
if (a[p][i][i] > 0) return 1;
return 0;
}
int main() {
init();
make_dp();
int l = 2, r = n + 1, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
if (l >= n + 1) ans = 0;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300 + 5;
const int MBIT = 15 + 5;
const int INF = 0x3f3f3f3f;
int n, m, MT, dp[MBIT][MAXN][MAXN];
int ans[2][MAXN][MAXN];
inline void umax(int& a, const int& b) { a = max(a, b); }
void init() {
MT = (int)floor(log2((long double)n));
for (int s = 0; s <= MT; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[s][i][j] = -INF;
}
dp[s][i][i] = 0;
}
}
}
void clr(int z) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans[z][i][j] = -INF;
}
ans[z][i][i] = 0;
}
}
bool check(int step) {
int z = 0;
clr(z);
for (int s = 0; s <= MT; s++) {
if (((step >> s) & 1) == 0) continue;
z ^= 1;
clr(z);
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
umax(ans[z][i][j], ans[z ^ 1][i][k] + dp[s][k][j]);
}
}
}
}
for (int i = 1; i <= n; i++) {
if (ans[z][i][i] > 0) return true;
}
return false;
}
int main() {
int u, v, a, b;
while (~scanf("%d %d", &n, &m)) {
init();
for (int i = 1; i <= m; i++) {
scanf("%d %d %d %d", &u, &v, &a, &b);
dp[0][u][v] = a, dp[0][v][u] = b;
}
for (int s = 1; s <= MT; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
if (dp[s - 1][i][k] == -INF) continue;
for (int j = 1; j <= n; j++) {
umax(dp[s][i][j], dp[s - 1][i][k] + dp[s - 1][k][j]);
}
}
}
}
int lb = 2, ub = n + 1, mid;
while (lb <= ub) {
mid = (lb + ub) >> 1;
if (check(mid))
ub = mid - 1;
else
lb = mid + 1;
}
if (lb >= n + 1) lb = 0;
printf("%d\n", lb);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct mat {
int a[305][305];
};
mat c[15];
int n, m;
mat operator*(const mat &a, const mat &b) {
int i, j, k;
mat r;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j)
r.a[i][j] = 0;
else
r.a[i][j] = -1 << 30;
for (k = 0; k < n; k++) {
if (a.a[i][k] != -1 << 30 || b.a[i][j] != -1 << 30)
r.a[i][j] = max(r.a[i][j], a.a[i][k] + b.a[k][j]);
}
}
}
return r;
}
bool judge(const mat &x) {
int i;
for (i = 0; i < n; i++) {
if (x.a[i][i] > 0) return true;
}
return false;
}
int main() {
int i, j, t, p = -1, s = 1;
mat d, w;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j)
d.a[i][j] = 0;
else
d.a[i][j] = -1 << 30;
}
}
for (i = 0; i < m; i++) {
int u, v, x, y;
scanf("%d%d%d%d", &u, &v, &x, &y);
d.a[u - 1][v - 1] = x;
d.a[v - 1][u - 1] = y;
}
t = n;
while (t != 0) {
t >>= 1;
p++;
}
c[0] = d;
for (i = 1; (1 << i) <= n; i++) c[i] = c[i - 1] * c[i - 1];
w = d;
for (i = p; i >= 0; i--) {
mat r = w * c[i];
if (!judge(r)) {
w = r;
s += 1 << i;
}
}
w = w * d;
s++;
if (judge(w) == true)
printf("%d\n", s);
else
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305;
const int inf = 1000000000;
int n, m;
struct matrix {
int dis[maxn][maxn];
} origin, power[10], tmp;
inline matrix operator*(const matrix &a, const matrix &b) {
static matrix res;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
res.dis[i][j] = -inf;
else
res.dis[i][j] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) {
if (a.dis[i][k] != -inf && b.dis[k][j] != -inf)
res.dis[i][j] = max(res.dis[i][j], a.dis[i][k] + b.dis[k][j]);
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) origin.dis[i][j] = -inf;
for (int i = 1, x, y, v1, v2; i <= m; i++) {
scanf("%d%d%d%d", &x, &y, &v1, &v2);
origin.dis[x][y] = v1;
origin.dis[y][x] = v2;
}
power[0] = tmp = origin;
int maxlog;
for (int i = 1; (1 << i) <= n; i++) {
power[i] = power[i - 1] * power[i - 1];
maxlog = i;
}
int ans = 1;
for (int i = maxlog; i >= 0; i--) {
origin = tmp * power[i];
bool ok = false;
for (int i = 1; i <= n && !ok; i++) ok |= (origin.dis[i][i] > 0);
if (!ok) {
tmp = origin;
ans += 1 << i;
}
}
tmp = tmp * power[0];
ans++;
for (int i = 1; i <= n; i++)
if (tmp.dis[i][i] > 0) {
printf("%d\n", ans);
return 0;
}
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 305;
int graph[MAXN][MAXN];
int n, m;
struct mat {
int a[MAXN][MAXN];
mat() {
for (int i = 1; i <= 300; i++)
for (int j = 1; j <= 300; j++) a[i][j] = -(int)1e9;
for (int i = 1; i <= 300; i++) a[i][i] = 0;
}
mat operator*(mat b) const {
mat r;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
r.a[i][j] = max(r.a[i][j], a[i][k] + b.a[k][j]);
return r;
}
} base[15];
mat power(mat x, int n) {
n--;
mat res = x;
while (n) {
if (n & 1) res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
bool chk(mat &res) {
for (int i = 1; i <= n; i++)
if (res.a[i][i] > 0) return true;
return false;
}
signed main() {
cin.tie(0)->sync_with_stdio(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, uv, vu;
cin >> u >> v >> uv >> vu;
base[0].a[u][v] = uv;
base[0].a[v][u] = vu;
}
for (int i = 1; i <= 9; i++) base[i] = base[i - 1] * base[i - 1];
if (!chk(base[9])) return cout << 0, 0;
mat res;
int ans = 0;
for (int i = 8; i >= 0; i--) {
mat pp = res * base[i];
if (!chk(pp)) {
res = pp;
ans += (1 << i);
}
}
cout << ans + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 5, INF = 0x3f3f3f3f;
int n, m;
int f[N][N][N], dp[N][N][N];
int ans;
int main() {
scanf("%d%d", &n, &m);
memset(f, 0xcf, sizeof(f));
memset(dp, 0xcf, sizeof(f));
for (int i = 1; i <= n; ++i) f[0][i][i] = 0;
for (int i = 1; i <= m; ++i) {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
f[0][x][y] = dp[1][x][y] = a;
f[0][y][x] = dp[1][y][x] = b;
}
for (int p = 1; p <= 9; ++p)
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
f[p][i][j] = max(f[p][i][j], f[p - 1][i][k] + f[p - 1][k][j]);
for (int i = 1; i <= n; ++i)
if (f[9][i][i] > 0) ans = 1;
if (!ans) {
printf("0");
return 0;
}
for (int q = 9; q >= 0; --q) {
ans += (1 << q);
memset(dp[ans], 0xcf, sizeof(dp[ans]));
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dp[ans][i][j] =
max(dp[ans][i][j], dp[ans - (1 << q)][i][k] + f[q][k][j]);
for (int i = 1; i <= n; ++i)
if (dp[ans][i][i] > 0) {
ans -= (1 << q);
break;
}
}
printf("%d\n", ++ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int vfMpos, vcMpos;
int vfLpos, vcLpos;
double vfMax, vcMax;
double vfLax, vcLax;
inline Node() {
vfMpos = vcMpos = vfLpos = vcLpos = vfMax = vcMax = vfLax = vcLax = 0;
}
};
struct Seg {
Node t[1 << 2];
inline Node Merge(Node tl, Node tr) {
Node t;
if (tl.vfMax > tr.vfMax) {
t.vfMax = tl.vfMax;
t.vfMpos = tl.vfMpos;
if (tl.vfLax > tr.vfMax)
t.vfLax = tl.vfLax, t.vfLpos = tl.vfLpos;
else
t.vfLax = tr.vfMax, t.vfLpos = tr.vfMpos;
} else {
t.vfMax = tr.vfMax;
t.vfMpos = tr.vfMpos;
if (tr.vfLax > tl.vfMax)
t.vfLax = tr.vfLax, t.vfLpos = tr.vfLpos;
else
t.vfLax = tl.vfMax, t.vfLpos = tl.vfMpos;
}
if (tl.vcMax > tr.vcMax) {
t.vcMax = tl.vcMax;
t.vcMpos = tl.vcMpos;
if (tl.vcLax > tr.vcMax)
t.vcLax = tl.vcLax, t.vcLpos = tl.vcLpos;
else
t.vcLax = tr.vcMax, t.vcLpos = tr.vcMpos;
} else {
t.vcMax = tr.vcMax;
t.vcMpos = tr.vcMpos;
if (tr.vcLax > tl.vcMax)
t.vcLax = tr.vcLax, t.vcLpos = tr.vcLpos;
else
t.vcLax = tl.vcMax, t.vcLpos = tl.vcMpos;
}
return t;
}
void Build(int l, int r, int now) {
if (l == r) {
return;
}
int mid = (l + r) >> 1;
Build(l, mid, (now << 1));
Build(mid + 1, r, (now << 1 | 1));
t[now] = Merge(t[(now << 1)], t[(now << 1 | 1)]);
}
Node qry(int L, int R, int l, int r, int now) {
if (l == L && r == R) return t[now];
int mid = (l + r) >> 1;
if (mid >= R) return qry(L, R, l, mid, (now << 1));
if (mid < L)
return qry(L, R, mid + 1, r, (now << 1 | 1));
else {
Node tl = qry(L, mid, l, mid, (now << 1));
Node tr = qry(mid + 1, R, mid + 1, r, (now << 1 | 1));
return Merge(tl, tr);
}
}
} T;
const int oo = 0x3f3f3f3f;
int f[10][310][310], ans[2][310][310], n;
bool ok(int x) {
int k, now = 0, i, j, p;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) ans[0][i][j] = i == j ? 0 : -oo;
for (k = 0; (1 << k) <= x; k++)
if (x & (1 << k)) {
now ^= 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) ans[now][i][j] = -oo;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (p = 1; p <= n; p++)
ans[now][i][j] =
max(ans[now][i][j], ans[now ^ 1][i][p] + f[k][p][j]);
}
for (i = 1; i <= n; i++)
if (ans[now][i][i] > 0) return 1;
return 0;
}
int main() {
int i, j, k, m, p, q, x, y, z, w, l, r, mid;
scanf("%d%d", &n, &m);
for (k = 0; (1 << k) <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) f[k][i][j] = i == j ? 0 : -oo;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &x, &y, &z, &w);
f[0][x][y] = z;
f[0][y][x] = w;
}
for (k = 1; (1 << k) <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (x = 1; x <= n; x++)
f[k][i][j] = max(f[k][i][j], f[k - 1][i][x] + f[k - 1][x][j]);
l = 2;
r = n + 1;
while (l < r) {
mid = (l + r) / 2;
if (ok(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l % (n + 1));
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const int maxn = 300 + 10;
const int inf = 1e9 + 10;
int n, m;
struct matrix {
int a[maxn][maxn];
matrix() {
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++) a[i][j] = i == j ? 0 : -inf;
}
inline int *operator[](const int &x) { return a[x]; }
} mat[9];
inline matrix operator*(matrix &a, matrix &b) {
matrix ret;
for (int i = 0; i < n; i++)
for (int k = 0; k < n; k++)
for (int j = 0; j < n; j++) ret[i][j] = max(ret[i][j], a[i][k] + b[k][j]);
return ret;
}
int ans;
int32_t main() {
n = in(), m = in();
for (int i = 0; i < m; i++) {
int v = in() - 1, u = in() - 1;
mat[0][v][u] = in(), mat[0][u][v] = in();
}
for (int i = 1; i < 9; i++) mat[i] = mat[i - 1] * mat[i - 1];
matrix cur;
for (int i = 8; i >= 0; i--) {
matrix shit = cur * mat[i];
bool fl = false;
for (int node = 0; node < n && !fl; node++)
if (shit[node][node] > 0) fl = true;
if (!fl) ans += (1 << i), cur = shit;
}
if (ans == (1 << 9) - 1) return cout << 0 << endl, 0;
cout << ans + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 333;
int g[maxn][maxn], a[maxn][maxn], d[maxn][maxn];
void mul(int x[maxn][maxn], int y[maxn][maxn], const int n) {
static int c[maxn][maxn], mid[maxn][maxn];
for (int _n(n), i(0); i < _n; i++)
for (int _n(n), j(0); j < _n; j++) c[i][j] = -1011111111;
for (int _n(n), i(0); i < _n; i++)
for (int _n(n), j(0); j < _n; j++)
for (int _n(n), k(0); k < _n; k++)
c[i][j] = max(c[i][j], x[i][k] + y[k][j]);
memcpy(x, c, sizeof(c));
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int _n(n), i(0); i < _n; i++)
for (int _n(n), j(0); j < _n; j++) g[i][j] = i == j ? 0 : -1011111111 / 20;
for (int _n(m), it(0); it < _n; it++) {
int i, j;
scanf("%d%d", &i, &j);
--i, --j;
scanf("%d%d", &g[i][j], &g[j][i]);
}
int lo = 2, hi = n + 1, ans = 0;
while (lo <= hi) {
const int mid = (lo + hi) >> 1;
memcpy(a, g, sizeof(g));
for (int _n(n), i(0); i < _n; i++)
for (int _n(n), j(0); j < _n; j++)
d[i][j] = i == j ? 0 : -1011111111 / 20;
for (int i = mid; i; i >>= 1, mul(a, a, n))
if (i & 1) mul(d, a, n);
bool ok = true;
for (int _n(n), i(0); i < _n; i++)
if (d[i][i] > 0) {
ok = false;
}
if (ok)
lo = mid + 1;
else
hi = mid - 1, ans = mid;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300 + 10;
const int maxm = maxn * (maxn - 1);
const int inf = 1e9 + 10;
const int maxk = 10;
int d[maxk][maxn][maxn];
int t[maxn][maxn], nd[maxn][maxn];
int n, m;
void work(int c[][maxn], int a[][maxn], int b[][maxn]) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = -inf;
for (int k = (1); k <= (n); ++k)
for (int i = (1); i <= (n); ++i) {
int j;
for (j = 1; j + 3 <= n; j += 4) {
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
((c[i][j + 1]) > (a[i][k] + b[k][j + 1])
? 0
: c[i][j + 1] = a[i][k] + b[k][j + 1]);
((c[i][j + 2]) > (a[i][k] + b[k][j + 2])
? 0
: c[i][j + 2] = a[i][k] + b[k][j + 2]);
((c[i][j + 3]) > (a[i][k] + b[k][j + 3])
? 0
: c[i][j + 3] = a[i][k] + b[k][j + 3]);
}
for (; j <= n; ++j)
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
}
}
bool judge(int a[][maxn]) {
for (int i = (1); i <= (n); ++i)
if (a[i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
d[0][i][j] = (i == j ? 0 : -inf);
}
int u, v;
for (int i = (1); i <= (m); ++i)
scanf("%d%d", &u, &v), scanf("%d%d", &d[0][u][v], &d[0][v][u]);
memcpy(t, d[0], sizeof t);
for (int v = (0); v <= (8); ++v) work(d[v + 1], d[v], d[v]);
if (!judge(d[9])) {
printf("0\n");
return 0;
}
int ans = 1;
for (int v = 8; v >= 0; --v) {
work(nd, d[v], t);
if (!judge(nd)) {
memcpy(t, nd, sizeof t);
ans += (1 << v);
}
}
printf("%d\n", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300;
const int INF = 1 << 29;
int ans;
const int ITER = 11;
int g[ITER][MAXN][MAXN];
int a[MAXN][MAXN];
int b[MAXN][MAXN];
int n, m;
int main() {
scanf("%d", &n);
for (int it = 0; it < ITER; it++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[it][i][j] = INF * (i != j);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
--a, --b;
g[0][a][b] = -c;
g[0][b][a] = -d;
}
for (int it = 1; it < ITER; it++) {
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
if (g[it - 1][i][k] != INF)
for (int j = 0; j < n; j++)
if (g[it - 1][k][j] != INF)
g[it][i][j] = min(g[it][i][j], g[it - 1][i][k] + g[it - 1][k][j]);
}
bool ok = false;
for (int i = 0; i < n; i++)
if (g[ITER - 1][i][i] < 0) ok = true;
if (!ok) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = INF * (i != j);
int ans = 0;
for (int it = ITER - 1; it >= 0; it--) {
bool ok = false;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
if (a[i][k] != INF && g[it][k][i] != INF && a[i][k] + g[it][k][i] < 0) {
ok = true;
}
if (!ok) {
ans += (1 << it);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
b[i][j] = INF;
for (int k = 0; k < n; k++)
if (a[i][k] != INF && g[it][k][j] != INF)
b[i][j] = min(b[i][j], a[i][k] + g[it][k][j]);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = b[i][j];
}
}
cout << ans + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
int f[15][N][N], g[3][N][N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int k = 0; k < 10; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
f[k][i][j] = -1e9;
else
f[k][i][j] = 0;
for (int i = 1; i <= m; i++) {
int x, y, z, w;
scanf("%d%d%d%d", &x, &y, &z, &w);
f[0][x][y] = z;
f[0][y][x] = w;
}
for (int k = 1; k < 10; k++)
for (int z = 1; z <= n; z++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
f[k][i][j] = max(f[k][i][j], f[k - 1][i][z] + f[k - 1][z][j]);
int ans = 0, t = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) g[0][i][j] = -1e9;
for (int k = 9; k >= 0; k--) {
int x = ans + (1 << k);
if (x > n) continue;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
g[t][i][j] = -1e9;
else
g[t][i][j] = 0;
for (int z = 1; z <= n; z++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
g[t][i][j] = max(g[t][i][j], g[t ^ 1][i][z] + f[k][z][j]);
bool flag = 0;
for (int i = 1; i <= n; i++)
if (g[t][i][i] > 0) {
flag = 1;
break;
}
if (flag) continue;
ans = x;
t ^= 1;
}
printf("%d\n", (ans + 1) % (n + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300 + 5;
const int MBIT = 15 + 5;
const int INF = 0x3f3f3f3f;
int n, m, MT, dp[MBIT][MAXN][MAXN];
int ans[2][MAXN][MAXN];
inline void umax(int& a, const int& b) { a = max(a, b); }
void init() {
MT = (int)floor(log2((long double)n));
for (int s = 0; s <= MT; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[s][i][j] = -INF;
}
dp[s][i][i] = 0;
}
}
}
void clr(int z) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans[z][i][j] = -INF;
}
ans[z][i][i] = 0;
}
}
bool check(int step) {
int z = 0;
clr(z);
for (int s = 0; s <= MT; s++) {
if (((step >> s) & 1) == 0) continue;
z ^= 1;
clr(z);
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
umax(ans[z][i][j], ans[z ^ 1][i][k] + dp[s][k][j]);
}
}
}
}
for (int i = 1; i <= n; i++) {
if (ans[z][i][i] > 0) return true;
}
return false;
}
int main() {
int u, v, a, b;
while (~scanf("%d %d", &n, &m)) {
init();
for (int i = 1; i <= m; i++) {
scanf("%d %d %d %d", &u, &v, &a, &b);
dp[0][u][v] = a, dp[0][v][u] = b;
}
for (int s = 1; s <= MT; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
if (dp[s - 1][i][k] == -INF) continue;
for (int j = 1; j <= n; j++) {
umax(dp[s][i][j], dp[s - 1][i][k] + dp[s - 1][k][j]);
}
}
}
}
int lb = 2, ub = n + 1, mid;
while (lb <= ub) {
mid = (lb + ub) >> 1;
if (check(mid))
ub = mid - 1;
else
lb = mid + 1;
}
if (lb >= n + 1) lb = 0;
printf("%d\n", lb);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct Graph {
int a[300][300];
int *operator[](int x) { return a[x]; }
void operator*=(Graph &b) {
static Graph temp;
int i, j, k, *p;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
p = &temp[i][j];
*p = -0x3f3f3f3f;
for (k = 0; k < n; k++) {
*p = max(*p, a[i][k] + b[k][j]);
}
}
}
*this = temp;
}
bool check() {
for (int i = 0; i < n; i++)
if (a[i][i] > 0) return 1;
return 0;
}
} T[20], In, now, temp;
int main() {
int m, i, j, k, x, y, a, b, ans;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (i != j) In[i][j] = -0x3f3f3f3f;
T[0] = In;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &x, &y, &a, &b);
x--, y--;
T[0][x][y] = max(T[0][x][y], a), T[0][y][x] = max(T[0][y][x], b);
}
for (i = 1; (1 << i) <= n; i++) {
T[i] = T[i - 1];
T[i] *= T[i - 1];
}
for (k = i--, now = In, ans = 0; i >= 0; i--) {
temp = now;
temp *= T[i];
if (!temp.check()) ans |= 1 << i, now = temp;
}
if (ans == (1 << k) - 1)
puts("0");
else
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305, lgN = 10, inf = ~0u >> 2;
typedef long long matrix[N][N];
matrix I, S, C, T, R, D[lgN];
int n;
void mult(matrix A, matrix B, matrix R) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
R[i][j] = -inf;
for (int x = 1; x <= n; ++x) R[i][j] = max(R[i][j], A[i][x] + B[x][j]);
}
}
void copy_mat(matrix dest, const matrix src) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dest[i][j] = src[i][j];
}
int solve() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) S[i][j] = I[i][j] = (-(~0ULL >> 4)) * (i != j);
copy_mat(R, I);
for (int i = 1, a, b, c, d; i <= m; ++i) {
scanf("%d%d%d%d", &a, &b, &c, &d);
S[a][b] = c;
S[b][a] = d;
}
copy_mat(D[0], S);
for (int i = 1; i < lgN; ++i) mult(D[i - 1], D[i - 1], D[i]);
int res(0);
for (int i = lgN - 1; i >= 0; --i) {
mult(R, D[i], T);
bool fnd = false;
for (int j = 1; !fnd && j <= n; ++j)
if (T[j][j] > 0) fnd = true;
if (!fnd) {
res += 1 << i;
copy_mat(R, T);
}
}
if (res > n + 10)
puts("0");
else
printf("%d\n", res + 1);
return 0;
}
int main() { return solve(); }
|
#include <bits/stdc++.h>
using namespace std;
struct matrix {
int a[300][300];
};
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
matrix d[10];
int n, m;
matrix mul(matrix a, matrix b, int x) {
matrix c;
for (int i = 0; i < x; i++)
for (int j = 0; j < x; j++) {
c.a[i][j] = max(a.a[i][j], b.a[i][j]);
for (int k = 0; k < x; k++)
c.a[i][j] = max(c.a[i][j], a.a[i][k] + b.a[k][j]);
}
return c;
}
bool find(int k) {
matrix x;
int l = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) x.a[i][j] = d[0].a[i][j];
k--;
while (k > 0) {
if (k % 2) x = mul(x, d[l], n);
k = k / 2;
l++;
}
for (int i = 0; i < n; i++)
if (x.a[i][i] > 0) return true;
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) d[0].a[i][j] = -100000000;
d[0].a[i][i] = 0;
}
for (int i = 0; i < m; i++) {
int x, y, a, b;
cin >> x >> y >> a >> b;
d[0].a[x - 1][y - 1] = a;
d[0].a[y - 1][x - 1] = b;
}
for (int i = 1; i < 10; i++) d[i] = mul(d[i - 1], d[i - 1], n);
int l, r, ans;
ans = 0;
l = 1;
r = n;
while (l <= r) {
int tmp = (l + r) / 2;
if (find(tmp)) {
ans = tmp;
r = tmp - 1;
} else
l = tmp + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
const int INF = 1001001001;
int N;
struct Matrix {
int v[310][310];
Matrix &operator*=(const Matrix &a) {
Matrix b;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) {
b.v[i][j] = (i != j) ? INF : 0;
}
for (int i = 0; i < N; ++i)
for (int k = 0; k < N; ++k)
for (int j = 0; j < N; ++j) {
chmin(b.v[i][j], v[i][k] + a.v[k][j]);
}
return *this = b;
}
Matrix operator*(const Matrix &a) const { return Matrix(*this) *= a; }
};
ostream &operator<<(ostream &os, const Matrix &a) {
os << "[";
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) os << " " << a.v[i][j];
os << ";";
}
os << " ]";
return os;
}
int M;
Matrix D;
Matrix Ds[10];
int main() {
int i, u, v;
int c;
int k, x;
for (; ~scanf("%d%d", &N, &M);) {
for (u = 0; u < N; ++u)
for (v = 0; v < N; ++v) {
D.v[u][v] = (u != v) ? INF : 0;
}
for (i = 0; i < M; ++i) {
u = in() - 1;
v = in() - 1;
c = -in();
chmin(D.v[u][v], c);
c = -in();
chmin(D.v[v][u], c);
}
Ds[0] = D;
for (k = 1; k <= 8; ++k) Ds[k] = Ds[k - 1] * Ds[k - 1];
Matrix d, dd;
for (u = 0; u < N; ++u)
for (v = 0; v < N; ++v) {
d.v[u][v] = (u != v) ? INF : 0;
}
x = 0;
for (k = 8; k >= 0; --k) {
dd = d * Ds[k];
for (u = 0; u < N; ++u)
if (dd.v[u][u] < 0) break;
if (u == N) {
d = dd;
x |= 1 << k;
}
}
int ans = (x + 1 <= N) ? (x + 1) : 0;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 310, foo = INT_MIN;
int n, m;
int c[MAX][MAX];
int f[10][MAX][MAX], curf[MAX][MAX], tmp[MAX][MAX];
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = foo;
for (int i = (1); i <= (n); ++i) c[i][i] = 0;
for (int i = (1); i <= (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
scanf("%d%d", &c[a][b], &c[b][a]);
}
int pp = 31;
for (; pp >= 0; pp--)
if ((1 << pp) & n) break;
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) f[0][i][j] = c[i][j];
for (int k = (1); k <= (pp); ++k) {
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
auto &ele = f[k][i][j] = foo;
for (int mid = (1); mid <= (n); ++mid) {
int a = f[k - 1][i][mid], b = f[k - 1][mid][j];
if (a != foo && b != foo) ele = max(ele, a + b);
}
}
}
}
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) curf[i][j] = foo;
for (int i = (1); i <= (n); ++i) curf[i][i] = 0;
int step = pp + 1, cur = 0;
while (step) {
int mid = step - 1;
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
auto &ele = tmp[i][j] = foo;
for (int h = (1); h <= (n); ++h) {
int a = curf[i][h], b = f[mid][h][j];
if (a != foo && b != foo) {
ele = max(ele, a + b);
}
}
}
}
bool ok = 0;
for (int i = (1); i <= (n); ++i)
if (tmp[i][i] > 0) {
ok = 1;
break;
}
if (!ok) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) curf[i][j] = tmp[i][j];
cur += 1 << mid;
}
step = mid;
}
int ans = -1;
for (int i = (1); i <= (n); ++i)
if (curf[i][i] > 0) {
ans = cur;
break;
}
if (ans == -1) {
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
auto &ele = tmp[i][j] = foo;
for (int h = (1); h <= (n); ++h) {
int a = curf[i][h], b = f[0][h][j];
if (a != foo && b != foo) {
ele = max(ele, a + b);
}
}
}
}
for (int i = (1); i <= (n); ++i)
if (tmp[i][i] > 0) {
ans = cur + 1;
break;
}
}
if (ans == -1)
printf("%d\n", 0);
else
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
const int MAX = 333;
const int POW = 10;
int MATR[POW][MAX][MAX];
int BUF[MAX][MAX];
int BUF2[MAX][MAX];
const int NOT = -1111111;
void copyTo(int SRC[333][333], int DST[333][333]) {
int i, j;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++) DST[i][j] = SRC[i][j];
}
bool check(int X[333][333]) {
int i;
for (i = 0; i < N; i++)
if (X[i][i] > 0) return 1;
return 0;
}
void reset(int X[333][333]) {
int i, j;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (i == j)
X[i][j] = 0;
else
X[i][j] = NOT;
}
void mult(int A[333][333], int B[333][333], int C[333][333]) {
reset(C);
int i, j, k, X;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++) {
for (k = 0; k < N; k++)
if (A[i][k] != NOT && B[k][j] != NOT) {
X = A[i][k] + B[k][j];
if (X > C[i][j]) C[i][j] = X;
}
}
}
bool chekkpow(int P) {
reset(BUF);
int i;
for (i = 0; i < POW; i++)
if ((P & (1 << i)) != 0) {
mult(BUF, MATR[i], BUF2);
copyTo(BUF2, BUF);
}
return check(BUF);
}
int main() {
int i, j, a, b, x, y, c;
cin >> N >> M;
reset(MATR[0]);
for (i = 0; i < M; i++) {
cin >> a >> b >> x >> y;
a--;
b--;
MATR[0][a][b] = x;
MATR[0][b][a] = y;
}
for (i = 1; i < POW; i++) {
mult(MATR[i - 1], MATR[i - 1], MATR[i]);
}
if (!check(MATR[POW - 1])) {
cout << "0" << endl;
return 0;
}
a = 1;
b = N;
while (b - a > 1) {
c = (a + b) / 2;
if (chekkpow(c))
b = c;
else
a = c;
}
if (chekkpow(a))
c = a;
else if (chekkpow(b))
c = b;
else
c = 0;
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const int inf = mod;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T &a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
template <typename T>
inline void in(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
struct matrix {
vector<vector<long long>> v;
int x, y;
matrix(int n = 0, int m = 0, int value = 0) : x(n), y(m) {
for (long long i = 0; i < n; i++) {
v.push_back(vector<long long>(m, 0));
}
if (value == 1) {
for (long long i = 0; i < n; i++) v[i][i] = 1;
}
}
matrix operator*(const matrix &o) const {
matrix ans(x, o.y);
for (auto &v : ans.v) {
fill(v.begin(), v.end(), -1LL * inf * inf);
}
for (long long i = 0; i < x; i++) {
for (long long j = 0; j < o.y; j++) {
for (long long k = 0; k < y; k++) {
ans.v[i][j] = max(ans.v[i][j], v[i][k] + o.v[k][j]);
}
}
}
return ans;
}
matrix operator+(const matrix &o) const {
assert(x == o.x && y == o.y);
matrix ans = *this;
for (long long i = 0; i < x; i++) {
for (long long j = 0; j < y; j++) {
ans.v[i][j] += o.v[i][j];
ans.v[i][j] %= mod;
}
}
return ans;
}
friend bool fast(matrix a, long long b) {
matrix ans = a;
b--;
assert(a.x == a.y);
while (b) {
if (b & 1) {
b--;
ans = ans * a;
} else {
b /= 2;
a = a * a;
}
}
for (long long i = 0; i < a.x; i++) {
if (ans.v[i][i] > 0) return true;
}
return false;
}
void print() {
printf("row = %d, column = %d\n", x, y);
for (long long i = 0; i < x; i++) {
for (long long j = 0; j < y; j++) {
cout << v[i][j] << ' ';
}
cout << endl;
}
cout << endl;
}
};
matrix base[9];
int n, m;
int main() {
in(n);
in(m);
base[0] = matrix(n, n);
for (auto &v : base[0].v) {
fill(v.begin(), v.end(), -1LL * inf * inf);
}
for (long long i = 0; i < n; i++) base[0].v[i][i] = 0;
for (long long i = 0; i < m; i++) {
int u, v, to, from;
in(u);
in(v);
in(to);
in(from);
u--;
v--;
base[0].v[u][v] = to;
base[0].v[v][u] = from;
}
for (long long i = 1; i < 9; i++) {
base[i] = base[i - 1] * base[i - 1];
}
matrix temp(n, n);
for (auto &v : temp.v) {
fill(v.begin(), v.end(), -1LL * inf * inf);
}
for (long long i = 0; i < n; i++) temp.v[i][i] = 0;
int ans = 0;
for (long long i = 8; i >= 0; i--) {
matrix test = temp * base[i];
bool ok = 0;
for (long long i = 0; i < n; i++)
if (test.v[i][i]) ok = 1;
if (!ok) {
ans += 1 << i;
swap(test, temp);
}
}
if (ans + 1 > n) ans = -1;
cout << ans + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void no() {
cout << "0\n";
exit(0);
}
int INF = 1e9;
struct matr {
int n;
vector<vector<int> > a;
};
matr operator*(matr a, matr b) {
matr res;
int n = a.n;
res.n = n;
res.a.assign(n, vector<int>(n));
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
int cur = -INF;
for (int k = 0; k < n; ++k) {
cur = max(cur, a.a[i][k] + b.a[k][j]);
}
res.a[i][j] = cur;
}
return res;
}
matr pw(matr a, int n) {
if (n == 1) {
return a;
}
matr cur = pw(a, n / 2);
if (n % 2 == 0) {
return cur * cur;
} else {
return cur * cur * a;
}
}
matr G, last;
int Last = 1;
bool ok(int k) {
matr g;
if (Last < k) {
g = last * pw(G, k - Last);
} else
g = pw(G, k);
Last = k;
last = g;
for (int i = 0; i < g.n; ++i)
if (g.a[i][i] > 0) return true;
return false;
}
int main() {
int n, m, x, y, t;
cin >> n >> m;
G.a.assign(n, vector<int>(n, -INF));
G.n = n;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &x, &y);
--x;
--y;
scanf("%d", &t);
G.a[x][y] = t;
scanf("%d", &t);
G.a[y][x] = t;
}
for (int i = 0; i < n; ++i) G.a[i][i] = 0;
last = G;
if (!ok(n)) no();
int left = 0;
int right = n;
while (true) {
if (left == right) {
if (!ok(left)) no();
cout << left << endl;
return 0;
}
if (left + 1 == right) {
if (!ok(left)) {
if (!ok(right)) no();
cout << right << endl;
return 0;
}
cout << left << endl;
return 0;
}
int mid = left + right;
mid /= 2;
if (ok(mid)) {
right = mid;
} else
left = mid;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300 + 10;
const int maxm = maxn * (maxn - 1);
const int inf = 1e9 + 10;
const int maxk = 10;
int d[maxk][maxn][maxn];
int t[maxn][maxn], nd[maxn][maxn];
int n, m;
void work(int c[][maxn], int a[][maxn], int b[][maxn]) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = -inf;
for (int k = (1); k <= (n); ++k)
for (int i = (1); i <= (n); ++i) {
int j;
for (j = 1; j + 3 <= n; j += 4) {
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
((c[i][j + 1]) > (a[i][k] + b[k][j + 1])
? 0
: c[i][j + 1] = a[i][k] + b[k][j + 1]);
((c[i][j + 2]) > (a[i][k] + b[k][j + 2])
? 0
: c[i][j + 2] = a[i][k] + b[k][j + 2]);
((c[i][j + 3]) > (a[i][k] + b[k][j + 3])
? 0
: c[i][j + 3] = a[i][k] + b[k][j + 3]);
}
for (; j <= n; ++j)
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
}
}
bool judge(int a[][maxn]) {
for (int i = (1); i <= (n); ++i)
if (a[i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
d[0][i][j] = (i == j ? 0 : -inf);
}
int u, v;
for (int i = (1); i <= (m); ++i)
scanf("%d%d", &u, &v), scanf("%d%d", &d[0][u][v], &d[0][v][u]);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) t[i][j] = d[0][i][j];
for (int v = (0); v <= (8); ++v) {
work(d[v + 1], d[v], d[v]);
}
if (!judge(d[9])) {
printf("0\n");
return 0;
}
int ans = 1;
for (int v = 8; v >= 0; --v) {
work(nd, d[v], t);
if (!judge(nd)) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) t[i][j] = nd[i][j];
ans += (1 << v);
}
}
printf("%d\n", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (c < 48) c == '-' && (f = -1), c = getchar();
while (c > 47) x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int MAXN = 305;
int n, m;
struct Matrix {
int s[MAXN][MAXN];
int *operator[](int i) { return s[i]; }
inline void init() { memset(s, 0xc0, sizeof(s)); }
} mat[15], now, nxt;
Matrix operator*(Matrix a, Matrix b) {
Matrix res;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
res[i][j] = max(a[i][j], b[i][j]);
for (int k = 1; k <= n; ++k)
res[i][j] = max(res[i][j], a[i][k] + b[k][j]);
}
return res;
}
int main(int argc, char const *argv[]) {
n = read();
m = read();
now.init(), mat[0].init();
for (int i = 1; i <= n; ++i) now[i][i] = 0;
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
mat[0][u][v] = read(), mat[0][v][u] = read();
}
for (int i = 1; i <= 9; ++i) mat[i] = mat[i - 1] * mat[i - 1];
int ans = 0;
for (int i = 9; ~i; --i) {
int flag = 0;
nxt = now * mat[i];
for (int j = 1; j <= n; ++j)
if (nxt[j][j] > 0) {
flag = 1;
break;
}
if (flag) continue;
now = nxt, ans += (1 << i);
}
printf("%d\n", ans > n ? 0 : ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int n;
int mul(int a[300][300], int b[300][300]) {
int u, v, w, t[300][300];
for (u = 0; u < n; u++)
for (v = 0; v < n; v++) {
t[u][v] = -1000000000;
for (w = 0; w < n; w++) {
t[u][v] = max(t[u][v], a[u][w] + b[w][v]);
}
}
memcpy(a, t, sizeof(t));
}
void print(int a[300][300]) {
int u, v;
for (u = 0; u < n; u++) {
for (v = 0; v < n; v++) printf("%d ", a[u][v]);
putchar('\n');
}
}
int main() {
int m;
scanf("%d%d", &n, &m);
int i, u, v, a[300][300];
for (u = 0; u < n; u++)
for (v = 0; v < n; v++) a[u][v] = u == v ? 0 : -1000000000;
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
scanf("%d%d", &a[u][v], &a[v][u]);
}
int l = 2, h = n + 10;
while (l < h) {
m = (l + h) / 2;
int b[300][300];
memcpy(b, a, sizeof(b));
int c[300][300];
for (u = 0; u < n; u++)
for (v = 0; v < n; v++) c[u][v] = u == v ? 0 : -1000000000;
i = m;
while (i) {
if (i & 1) mul(c, b);
mul(b, b);
i >>= 1;
}
for (u = 0; u < n; u++)
if (c[u][u] > 0) break;
if (u != n)
h = m;
else
l = m + 1;
}
if (l == n + 10)
puts("0");
else
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1e9;
template <typename T>
class Matrix {
public:
int n, m;
std::vector<std::vector<T> > a;
Matrix() {}
Matrix(int _n, int _m) {
n = _n, m = _m;
a = std::vector<std::vector<T> >(n, std::vector<T>(m, -inf));
};
std::vector<T>& operator[](int i) { return a[i]; }
Matrix friend operator*(Matrix A, Matrix B) {
Matrix ans(A.n, B.m);
for (int k = 0; k < A.m; ++k)
for (int i = 0; i < A.n; ++i)
if (A[i][k] > -inf)
for (int j = 0; j < A.m; ++j)
ans[i][j] = std::max(ans[i][j], A[i][k] + B[k][j]);
return ans;
}
void out() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d ", a[i][j]);
puts("");
}
}
};
Matrix<int> f[10];
int n, m;
bool check(int p) {
Matrix<int> B(n, n);
for (int i = 0; i < B.n; i++) B[i][i] = 0;
for (int i = 0; i < 10; i++)
if (p >> i & 1) B = B * f[i];
for (int i = 0; i < B.n; i++)
if (B[i][i] > 0) return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
Matrix<int> A(n, n);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
int p, q;
scanf("%d%d", &p, &q);
A[u][v] = p;
A[v][u] = q;
}
for (int i = 0; i < n; i++) A[i][i] = 0;
f[0] = A;
for (int i = 1; i < 10; i++) f[i] = f[i - 1] * f[i - 1];
int l = 0, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (check(l))
printf("%d\n", l);
else
printf("0\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
int a[301][301], sz;
inline Matrix(int _sz = 0) {
sz = _sz;
for (int i = 1; i <= sz; i++)
for (int j = 1; j <= sz; j++) a[i][j] = ((i == j) ? 0 : -1000000010);
}
inline Matrix operator*(Matrix &b) const {
Matrix c(sz);
for (int i = 1; i <= sz; i++)
for (int j = 1; j <= sz; j++) {
c.a[i][j] = -1000000010;
for (int k = 1; k <= sz; k++)
c.a[i][j] = max(c.a[i][j], a[i][k] + b.a[k][j]);
}
return c;
}
};
int n, m, ans;
int main() {
scanf("%d%d", &n, &m);
Matrix w(n), p[11], t(n);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
scanf("%d%d", &w.a[x][y], &w.a[y][x]);
}
p[0] = w;
for (int i = 1; i <= 8; i++) p[i] = p[i - 1] * p[i - 1];
for (int i = 8; i >= 0; i--) {
Matrix temp = t * p[i];
bool flag = false;
for (int j = 1; j <= n; j++)
if (temp.a[j][j] > 0) {
flag = true;
break;
}
if (!flag) {
t = temp;
ans += (1 << i);
}
}
if (ans == 511)
printf("0");
else
printf("%d", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mx = 312;
int z[mx][mx];
int u[mx][mx];
int v[mx][mx];
int adj[31][mx][mx];
void _mult(int x[mx][mx], int y[mx][mx], int n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) z[i][j] = -inf;
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (x[i][k] == -inf) continue;
if (y[k][j] == -inf) continue;
z[i][j] = max(z[i][j], min(inf, x[i][k] + y[k][j]));
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) x[i][j] = max(x[i][j], max(y[i][j], z[i][j]));
}
int main() {
int n, m;
cin >> n >> m;
for (int k = 0; k < 31; k++)
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) adj[k][i][j] = -inf;
for (int i = 0; i < m; i++) {
int a, b, wab, wba;
cin >> a >> b >> wab >> wba;
a--, b--;
adj[0][a][b] = max(adj[0][a][b], wab);
adj[0][b][a] = max(adj[0][b][a], wba);
}
for (int p = 1; p < 31; p++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
adj[p][i][j] = adj[p - 1][i][j];
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (adj[p - 1][i][k] == -inf) continue;
if (adj[p - 1][k][j] == -inf) continue;
adj[p][i][j] =
max(adj[p][i][j], min(inf, adj[p - 1][i][k] + adj[p - 1][k][j]));
}
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) u[i][j] = -inf;
int ans = 0;
for (int p = 30; p >= 0; p--) {
bool poscycle = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) v[i][j] = u[i][j];
_mult(v, adj[p], n);
for (int i = 0; i < n; i++) poscycle |= (v[i][i] > 0);
if (poscycle) continue;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) u[i][j] = v[i][j];
ans += (1 << p);
}
_mult(u, adj[0], n);
bool poscycle = 0;
for (int i = 0; i < n; i++) poscycle |= (u[i][i] > 0);
if (!poscycle)
ans = 0;
else
ans++;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 2e5 + 5, INF = 1e9;
const bool debug = 0;
int n, m, a, b, c1, c2;
struct matrix {
vector<vector<int> > M;
int n, m;
matrix() {}
matrix(int nn, int mm) {
n = nn;
m = mm;
M.resize(n);
for (int i = 0; i < n; ++i) M[i].resize(m);
}
matrix(int nn, int mm, int z) {
n = nn;
m = mm;
M.resize(n);
for (int i = 0; i < n; ++i) M[i].resize(m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) M[i][j] = z;
}
vector<int>& operator[](int x) { return M[x]; }
};
matrix operator*(matrix& a, matrix& b) {
matrix c(a.n, b.m, -INF);
for (int i = 0; i < a.n; ++i)
for (int j = 0; j < b.m; ++j)
for (int k = 0; k < a.m; ++k)
if (a[i][k] > -INF && b[k][j] > -INF && c[i][j] < a[i][k] + b[k][j])
c[i][j] = a[i][k] + b[k][j];
return c;
}
matrix& operator*=(matrix& a, matrix& b) {
a = a * b;
return a;
}
bool h(matrix& a) {
for (int i = 0; i < a.n; ++i)
if (a[i][i] > 0) return true;
return false;
}
ostream& operator<<(ostream& out, matrix& a) {
for (int i = 0; i < a.n; ++i, out << endl)
for (int j = 0; j < a.m; ++j) out << a[i][j] << " ";
return out;
}
int main() {
if (debug) freopen("input.txt", "r", stdin);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
matrix g(n, n, -INF);
for (int i = 0; i < n; ++i) g[i][i] = 0;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> c1 >> c2;
--a;
--b;
g[a][b] = max(g[a][b], c1);
g[b][a] = max(g[b][a], c2);
}
int l = 1, r = n + 1;
vector<matrix> stpd(10);
stpd[0] = g;
for (int i = 1; i < 10; ++i) stpd[i] = stpd[i - 1] * stpd[i - 1];
for (int k = 9; k >= 0; --k) {
matrix pg = g * stpd[k];
if (!h(pg)) {
l += (1 << k);
g = pg;
}
}
cout << (l + 1 > n ? 0 : l + 1);
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 305;
const int inf = 0x7fffffff;
struct node {
int data[maxn][maxn], n;
node(int a = 0) : n(a) {}
node operator*(const node &ot) {
node ret(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ret.data[i][j] = -inf;
for (int h = 0; h < n; h++) {
if (data[i][h] == -inf || ot.data[h][j] == -inf) continue;
if (data[i][h] + ot.data[h][j] > ret.data[i][j])
ret.data[i][j] = data[i][h] + ot.data[h][j];
}
}
}
return ret;
}
} f, g;
int n, m;
node power(int a) {
if (a == 1) return f;
node t = power(a / 2);
return a & 1 ? t * t * f : t * t;
}
void init() {
scanf("%d%d", &n, &m);
f.n = n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) f.data[i][j] = (i != j) * (-inf);
}
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
scanf("%d%d", &f.data[x][y], &f.data[y][x]);
}
}
void work() {
int ans = 0, lower = 2, upper = n;
while (lower <= upper) {
int mid = (lower + upper) >> 1, flag = 0;
node t = power(mid);
for (int i = 0; i < n; i++) {
if (t.data[i][i] > 0) {
flag = 1;
break;
}
}
if (flag) {
ans = mid;
upper = mid - 1;
} else
lower = mid + 1;
}
printf("%d\n", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310, INF = (1 << 27);
int d[MAXN][MAXN];
int all[20][MAXN][MAXN];
int ans[MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = INF;
for (int i = 0; i < n; i++) d[i][i] = 0;
for (int i = 0; i < m; i++) {
int x, y, w1, w2;
cin >> x >> y >> w1 >> w2;
x--;
y--;
w1 = -w1;
w2 = -w2;
d[x][y] = w1;
d[y][x] = w2;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) all[0][i][j] = ans[i][j] = d[i][j];
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
bool hasNeg = false;
for (int i = 0; i < n; i++)
if (d[i][i] < 0) hasNeg = true;
if (!hasNeg) {
cout << 0 << endl;
return 0;
}
int ind;
for (ind = 1; (1 << ind) < n; ind++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
all[ind][i][j] = INF;
for (int k = 0; k < n; k++)
all[ind][i][j] =
min(all[ind][i][j], all[ind - 1][i][k] + all[ind - 1][k][j]);
}
}
ind--;
int length = 1;
while (ind >= 0) {
int tmp[MAXN][MAXN];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
tmp[i][j] = INF;
for (int k = 0; k < n; k++)
tmp[i][j] = min(tmp[i][j], ans[i][k] + all[ind][k][j]);
}
hasNeg = false;
for (int i = 0; i < n; i++)
if (tmp[i][i] < 0) hasNeg = true;
if (!hasNeg) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans[i][j] = tmp[i][j];
length += (1 << ind);
}
ind--;
}
cout << length + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
int n;
vector<vector<long long>> v;
Matrix() {}
Matrix(vector<vector<long long>> &_v) : n(_v.size()) { v = _v; }
Matrix(int &_n, long long _x) : n(_n), v(n, vector<long long>(n, _x)) {}
vector<long long> &operator[](int idx) { return v[idx]; }
Matrix operator*(Matrix &rhs) {
Matrix res(n, -(1 << 29));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
res[i][j] = max(res[i][j], v[i][k] + rhs[k][j]);
return move(res);
}
};
Matrix A[9];
Matrix operator^(Matrix &M, int &x) {
Matrix res(M.n, 0);
int i = 0;
bool b = true;
for (; x; x >>= 1, i++)
if (x & 1) {
res = b ? A[i] : res * A[i];
b = false;
}
return move(res);
}
bool check(Matrix &M, int k, int &n) {
Matrix B = M ^ k;
for (int i = 0; i < n; i++)
if (B[i][i] > 0) return true;
return false;
}
int findMin(Matrix &M, int &n) {
int l = 2, r = n + 1;
while (l != r) {
int mid = (l + r) >> 1;
bool b = check(M, mid, n);
b ? r = mid : l = mid + 1;
}
return (l != n + 1) * l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
Matrix M(n, -(1 << 29));
for (int i = 0; i < n; i++) M[i][i] = 0;
for (int i = 0; i < m; i++) {
int u, v, cu, cv;
cin >> u >> v >> cu >> cv;
u--;
v--;
M[u][v] = cu;
M[v][u] = cv;
}
A[0] = M;
for (int i = 1; i < 9; i++) {
A[i] = A[i - 1] * A[i - 1];
}
cout << findMin(M, n) << '\n';
cin.ignore(2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int maxN = 305;
int T[maxN][maxN], A[maxN][maxN], I[maxN][maxN], C[maxN][maxN];
int n, m;
void matExp(int e) {
while (e) {
if (e & 1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
C[i][j] = -INF;
for (int k = 0; k < n; k++) {
int poss = (I[i][k] + A[k][j]);
C[i][j] = (C[i][j] < poss ? poss : C[i][j]);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) I[i][j] = C[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
C[i][j] = -INF;
for (int k = 0; k < n; k++) {
int poss = (A[i][k] + A[k][j]);
C[i][j] = (C[i][j] < poss ? poss : C[i][j]);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) A[i][j] = C[i][j];
e >>= 1;
}
}
bool checkCycle(int &mid) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
I[i][j] = (i == j ? 0 : -INF);
A[i][j] = T[i][j];
}
matExp(mid);
for (int i = 0; i < n; i++) {
if (I[i][i] > 0) return true;
}
return false;
}
int main() {
;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
scanf("%ld%ld", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) T[i][j] = (i == j ? 0 : -INF);
for (int a = 0; a < m; a++) {
int i, j;
scanf("%ld%ld", &i, &j);
i--, j--;
scanf("%ld%ld", &T[i][j], &T[j][i]);
}
int l = 1, r = n, res = -1;
while (l <= r) {
int mid = l + ((r - l) >> 1);
if (checkCycle(mid)) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << (res == -1 ? 0 : res) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int f = 1, sum = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = (sum << 3) + (sum << 1) + ch - '0';
ch = getchar();
}
return f * sum;
}
const int N = 310, Log = 10, L = 12, Inf = 1e9 + 10;
int n, m;
struct matrix {
int a[N][N];
void init() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = -Inf;
}
matrix operator*(const matrix &b) const {
matrix c;
c.init();
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
c.a[i][j] = max(c.a[i][j], a[i][k] + b.a[k][j]);
return c;
}
} T[L];
int main() {
n = gi();
m = gi();
T[0].init();
for (int i = 1; i <= n; i++) T[0].a[i][i] = 0;
for (int i = 1; i <= m; i++) {
int u = gi(), v = gi();
T[0].a[u][v] = gi();
T[0].a[v][u] = gi();
}
for (int i = 1; i < Log; i++) T[i] = T[i - 1] * T[i - 1];
matrix now, o;
now.init();
o.init();
for (int i = 1; i <= n; i++) now.a[i][i] = 0;
int ans = 0;
for (int i = Log - 1; ~i; i--) {
o = now * T[i];
int flag = 0;
for (int j = 1; j <= n; j++)
if (o.a[j][j] > 0) {
flag = 1;
break;
}
if (flag) continue;
ans += (1 << i), now = o;
}
if (ans > n)
puts("0");
else
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e8, LOG = 11;
int N, m;
vector<vector<int> > operator+(const vector<vector<int> > &a,
const vector<vector<int> > &b) {
vector<vector<int> > c(N, vector<int>(N, -INF));
for (int k = 0; k < N; ++k)
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) {
c[i][j] = max(c[i][j], a[i][k] + b[k][j]);
}
return c;
}
bool check(const vector<vector<int> > &a) {
for (int i = 0; i < N; ++i)
if (a[i][i] > 0) return 1;
return 0;
}
vector<vector<int> > mtrxs[LOG];
int main() {
scanf("%d %d", &N, &m);
mtrxs[0].assign(N, vector<int>(N, -INF));
for (int i = 0; i < N; ++i) mtrxs[0][i][i] = 0;
vector<vector<int> > curMtrx = mtrxs[0];
int curNum = 0;
while (m--) {
int u, v;
scanf("%d %d", &u, &v);
--u, --v;
scanf("%d %d", &mtrxs[0][u][v], &mtrxs[0][v][u]);
}
for (int i = 1; i < LOG; ++i) mtrxs[i] = mtrxs[i - 1] + mtrxs[i - 1];
if (!check(mtrxs[LOG - 1])) return 0 * puts("0");
for (int i = LOG - 1; i >= 0; --i) {
vector<vector<int> > tmp = curMtrx + mtrxs[i];
if (!check(tmp)) {
curMtrx = move(tmp);
curNum += 1 << i;
}
}
printf("%d\n", curNum + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
int n, m, ans = 1;
int d[10][N][N];
int f[N][N], tmp[N][N];
int lg[N];
void init() {
for (int i = 1; i <= n; i++) {
lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
}
memset(d, -INF, sizeof d);
memset(f, -INF, sizeof f);
for (int i = 1; i <= n; i++) {
d[0][i][i] = 0;
f[i][i] = 0;
}
}
void floyd() {
for (int s = 1; s <= lg[n]; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[s][i][j] = max(d[s][i][j], d[s - 1][i][k] + d[s - 1][k][j]);
}
}
}
}
}
void solve() {
cin >> n >> m;
init();
while (m--) {
int u, v;
cin >> u >> v;
cin >> d[0][u][v] >> d[0][v][u];
}
floyd();
for (int s = 1; s <= lg[n]; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[s][i][j] = max(d[s][i][j], d[s - 1][i][k] + d[s - 1][k][j]);
}
}
}
}
for (int s = lg[n]; ~s; s--) {
memset(tmp, -INF, sizeof tmp);
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
tmp[i][j] = max(tmp[i][j], f[i][k] + d[s][k][j]);
}
}
}
bool flag = 0;
for (int i = 1; i <= n; i++) {
if (tmp[i][i] > 0) {
flag = 1;
break;
}
}
if (flag)
continue;
else {
ans += (1 << s);
memcpy(f, tmp, sizeof tmp);
}
}
if (ans > n)
cout << "0\n";
else
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c;
int x = 0;
int b = 1;
do {
c = getchar();
if (c == 45) b = -1;
} while (c > 57 || c < 48);
do x = x * 10 + c - 48, c = getchar();
while (c <= 57 && c >= 48);
x *= b;
return x;
}
int n, m, t;
const int maxn = 300 + 5;
const int logn = 10 + 5;
int f[logn][maxn][maxn];
int g[maxn][maxn], w[maxn][maxn];
int main() {
n = read(), m = read();
t = log2(n);
memset(f, 0xcf, sizeof(f));
memset(w, 0xcf, sizeof(w));
for (int i = 1, x, y, z, l; i <= m; i++) {
x = read(), y = read();
z = read();
l = read();
f[0][x][y] = z, f[0][y][x] = l;
}
for (int i = 1; i <= n; i++) w[i][i] = f[0][i][i] = 0;
for (int s = 1; s <= 10; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
f[s][i][j] = max(f[s][i][j], f[s - 1][i][k] + f[s - 1][k][j]);
}
}
}
}
int ans = 0;
for (int s = 10; s >= 0; s--) {
memset(g, 0xcf, sizeof(g));
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
g[i][j] = max(g[i][j], w[i][k] + f[s][k][j]);
}
}
}
int sig = 0;
for (int i = 1; i <= n; i++)
if (g[i][i] > 0) sig = 1;
if (sig)
continue;
else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
w[i][j] = g[i][j];
}
}
ans += (1 << s);
}
}
printf("%d\n", ans >= n ? 0 : ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN(300);
int n, m;
int dist[10][MAXN][MAXN], dp[MAXN][MAXN], temp[MAXN][MAXN];
int main() {
int a, b, t1, t2;
int lg2, ans;
bool flag;
scanf("%d%d", &n, &m);
if (!m) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) dp[i][j] = dist[0][i][j] = -300000000;
dp[i][i] = dist[0][i][i] = 0;
}
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", &a, &b, &t1, &t2);
if (t1 + t2 > 0) {
printf("2\n");
return 0;
}
--a, --b;
dist[0][a][b] = t1;
dist[0][b][a] = t2;
}
for (t1 = n, lg2 = -1; t1; t1 >>= 1) ++lg2;
for (int k = 1; k <= lg2 + 1; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
dist[k][i][j] = dist[k - 1][i][j];
for (t1 = 0; t1 < n; ++t1) {
t2 = dist[k - 1][i][t1] + dist[k - 1][t1][j];
dist[k][i][j] < t2 && (dist[k][i][j] = t2);
}
}
flag = false;
for (int i = 0; i < n; ++i)
if (dist[lg2 + 1][i][i] > 0) {
flag = true;
break;
}
if (!flag) {
printf("0\n");
return 0;
}
ans = 1;
for (int k = lg2; ~k; --k) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
temp[i][j] = dp[i][j];
for (int t1 = 0; t1 < n; ++t1) {
t2 = dp[i][t1] + dist[k][t1][j];
temp[i][j] < t2 && (temp[i][j] = t2);
}
}
flag = false;
for (int i = 0; i < n; ++i)
if (temp[i][i] > 0) {
flag = true;
break;
}
if (!flag) {
ans += 1 << k;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) dp[i][j] = temp[i][j];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 302, inf = 1000000000;
int n, m, res;
int c[10][N][N], curr[N][N], pre[N][N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
c[0][i][j] = (i == j ? 0 : -inf);
pre[i][j] = c[0][i][j];
}
for (int i = 1; i <= m; i++) {
int u, v, c1, c2;
scanf("%d %d %d %d", &u, &v, &c1, &c2);
c[0][u][v] = c1;
c[0][v][u] = c2;
}
for (int step = 0; step < 9; step++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) c[step + 1][i][j] = c[step][i][j];
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
c[step + 1][i][j] =
max(c[step + 1][i][j], c[step][i][k] + c[step][k][j]);
}
bool found = false;
for (int i = 1; i <= n && !found; i++)
if (c[9][i][i] > 0) found = true;
if (!found) {
printf("%d\n", 0);
return 0;
}
for (int x = 9; x >= 0; x--) {
if (found)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) curr[i][j] = pre[i][j];
found = false;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
curr[i][j] = max(curr[i][j], pre[i][k] + c[x][k][j]);
for (int i = 1; i <= n && !found; i++)
if (curr[i][i] > 0) found = true;
if (!found) {
res += (1 << x);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) pre[i][j] = curr[i][j];
}
}
printf("%d\n", res + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300, MAXK = 10;
int n, m, x, y, z, w, Ans;
int dp[MAXK + 5][MAXN + 5][MAXN + 5];
int tmp[MAXN + 5][MAXN + 5], now[MAXN + 5][MAXN + 5];
int main() {
memset(now, 0xcf, sizeof(now));
memset(dp, 0xcf, sizeof(dp));
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d %d", &x, &y, &z, &w);
dp[0][x][y] = z;
dp[0][y][x] = w;
}
for (int i = 1; i <= n; i++) now[i][i] = 0, dp[0][i][i] = 0;
for (int s = 1; s <= MAXK; s++)
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dp[s][i][j] = max(dp[s][i][j], dp[s - 1][i][k] + dp[s - 1][k][j]);
for (int s = MAXK; s >= 0; s--) {
memset(tmp, 0xcf, sizeof(tmp));
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
tmp[i][j] = max(tmp[i][j], now[i][k] + dp[s][k][j]);
bool f = 0;
for (int i = 1; i <= n; i++)
if (tmp[i][i] > 0) {
f = 1;
break;
}
if (f)
continue;
else {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) now[i][j] = tmp[i][j];
Ans += 1 << s;
}
}
printf("%d\n", Ans >= n ? 0 : Ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 10000 * 10000 * 10;
const int MAXN = 300 + 10;
typedef long long matris[MAXN][MAXN];
matris mat, pw[MAXN], h;
int n, m;
void fill(int k) {
if (k == 0) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) pw[k][i][j] = mat[i][j];
return;
}
fill(k - 1);
matris temp;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
temp[i][j] = INF;
for (int l = 0; l < n; l++)
temp[i][j] = min(temp[i][j], pw[k - 1][i][l] + pw[k - 1][l][j]);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) pw[k][i][j] = temp[i][j];
}
matris now;
int d, last_d;
int find(int k) {
if (k == -1) {
for (int i = 0; i < n; i++)
if (now[i][i] < 0) return d;
return d + 1;
}
matris temp;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
temp[i][j] = INF;
for (int l = 0; l < n; l++)
temp[i][j] = min(temp[i][j], now[i][l] + pw[k][l][j]);
}
for (int i = 0; i < n; i++)
if (temp[i][i] < 0) {
return find(k - 1);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) now[i][j] = temp[i][j];
last_d = d;
d += pow(2, k);
return find(k - 1);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) h[i][j] = mat[i][j] = INF;
for (int i = 0; i < m; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--, b--;
mat[a][b] = -c;
mat[b][a] = -d;
}
for (int i = 0; i < n; i++) h[i][i] = 0, mat[i][i] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) now[i][j] = h[i][j];
fill(log2(n));
int ans = find(log2(n));
if (ans > n) ans = 0;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 310, P = INT_MIN / 10;
int w[10][N][N], s[N][N], t[N][N];
int main() {
int n, m, i, j, k, l, x, y, s1, s2, ans = 1, max, sum[10];
bool p;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) w[0][i][j] = P;
for (i = 1; i <= m; i++) {
scanf("%d %d %d %d", &x, &y, &s1, &s2);
w[0][x][y] = s1;
w[0][y][x] = s2;
}
for (i = 1; i <= n; i++) w[0][i][i] = 0;
sum[0] = 1;
i = 0;
while (sum[i] * 2 <= n) {
sum[i + 1] = sum[i] * 2;
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++) w[i + 1][j][k] = P;
for (l = 1; l <= n; l++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++)
if (w[i + 1][j][k] < w[i][j][l] + w[i][l][k])
w[i + 1][j][k] = w[i][j][l] + w[i][l][k];
i++;
}
max = i;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) s[i][j] = P;
for (i = 1; i <= n; i++) s[i][i] = 0;
for (i = max; i >= 0; i--) {
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++) t[j][k] = P;
for (l = 1; l <= n; l++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++) {
if (t[j][k] < s[j][l] + w[i][l][k]) t[j][k] = s[j][l] + w[i][l][k];
if (t[j][k] < w[i][j][l] + s[l][k]) t[j][k] = w[i][j][l] + s[l][k];
}
p = false;
for (j = 1; j <= n; j++)
if (t[j][j] > 0) {
p = true;
break;
}
if (!p) {
ans += sum[i];
memcpy(s, t, sizeof(t));
}
}
if (ans <= n)
printf("%d", ans);
else
printf("0");
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 5, INF = 0x3f3f3f3f;
int n, m;
int f[N][N][N], dp[N][N][N];
int ans;
int main() {
scanf("%d%d", &n, &m);
memset(f, 0xcf, sizeof(f));
memset(dp, 0xcf, sizeof(f));
for (int i = 1; i <= n; ++i) f[0][i][i] = 0;
for (int i = 1; i <= m; ++i) {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
f[0][x][y] = dp[1][x][y] = a;
f[0][y][x] = dp[1][y][x] = b;
}
for (int p = 1; p <= 9; ++p)
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
f[p][i][j] = max(f[p][i][j], f[p - 1][i][k] + f[p - 1][k][j]);
for (int i = 1; i <= n; ++i)
if (f[9][i][i] > 0) ans = 1;
if (!ans) {
printf("0");
return 0;
}
for (int q = 9; q >= 0; --q) {
ans += (1 << q);
memset(dp[ans], 0xcf, sizeof(dp[ans]));
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dp[ans][i][j] =
max(dp[ans][i][j], dp[ans - (1 << q)][i][k] + f[q][k][j]);
for (int i = 1; i <= n; ++i)
if (dp[ans][i][i] > 0) i += n, ans -= (1 << q);
}
printf("%d\n", ++ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 3e2 + 5;
inline int read() {
char c = getchar();
int fh = 0;
bool x = false;
while (!isdigit(c)) x |= (c == '-'), c = getchar();
while (isdigit(c)) fh = (fh << 1) + (fh << 3) + (c ^ 48), c = getchar();
return x ? -fh : fh;
}
int n, m, f[15][N][N], now[N][N], tmp[N][N], ans;
int main() {
n = read(), m = read();
memset(f, -0x3f, sizeof(f));
memset(tmp, -0x3f, sizeof(tmp));
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
f[0][u][v] = read();
f[0][v][u] = read();
}
for (int i = 1; i <= n; ++i) f[0][i][i] = tmp[i][i] = 0;
for (int p = 1; p <= log2(n); ++p)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k)
f[p][i][j] = (f[p][i][j] > f[p - 1][i][k] + f[p - 1][k][j]
? f[p][i][j]
: f[p - 1][i][k] + f[p - 1][k][j]);
for (int p = log2(n); p >= 0; --p) {
memset(now, -0x3f, sizeof(now));
for (int i = 1; i <= n; ++i) now[i][i] = 0;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
now[i][j] =
(now[i][j] > tmp[i][k] + f[p][k][j] ? now[i][j]
: tmp[i][k] + f[p][k][j]);
bool f1 = false;
for (int i = 1; i <= n; ++i)
if (now[i][i] > 0) {
f1 = true;
break;
}
if (f1)
continue;
else {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) tmp[i][j] = now[i][j];
ans += 1 << p;
}
}
printf("%d\n", ans >= n ? 0 : ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
struct matrix {
int a[302][302];
};
matrix two[10];
matrix operator*(const matrix &A, const matrix &B) {
int i, j, k;
matrix C;
for ((i) = 0; (i) < (int)(N); (i)++)
for ((j) = 0; (j) < (int)(N); (j)++)
C.a[i][j] = ((i == j) ? 0 : -(1 << 29));
for ((i) = 0; (i) < (int)(N); (i)++)
for ((j) = 0; (j) < (int)(N); (j)++)
for ((k) = 0; (k) < (int)(N); (k)++)
C.a[i][k] = max(C.a[i][k], A.a[i][j] + B.a[j][k]);
return C;
}
int main(void) {
int M, i, j, x, y, c1, c2;
scanf("%d%d", &N, &M);
matrix A;
for ((i) = 0; (i) < (int)(N); (i)++)
for ((j) = 0; (j) < (int)(N); (j)++)
A.a[i][j] = ((i == j) ? 0 : -(1 << 29));
for ((i) = 0; (i) < (int)(M); (i)++) {
scanf("%d%d%d%d", &x, &y, &c1, &c2);
x--;
y--;
A.a[x][y] = c1;
A.a[y][x] = c2;
}
two[0] = A;
for (i = 1; i <= 8; i++) two[i] = two[i - 1] * two[i - 1];
matrix B;
for ((i) = 0; (i) < (int)(N); (i)++)
for ((j) = 0; (j) < (int)(N); (j)++)
B.a[i][j] = ((i == j) ? 0 : -(1 << 29));
int ans = 1;
for (i = 8; i >= 0; i--) {
matrix C = B * two[i];
bool positive = false;
for ((j) = 0; (j) < (int)(N); (j)++)
if (C.a[j][j] > 0) positive = true;
if (!positive) {
B = C;
ans += (1 << i);
}
}
if (ans == 512) ans = 0;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(305);
int n, m, a[MAXN][MAXN], b[10][MAXN][MAXN], d[MAXN][MAXN], t[MAXN][MAXN];
bool ok(int x) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = a[i][j];
int p = 0;
while (x) {
if (x & 1) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) t[i][j] = INF;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
t[i][j] = min(t[i][j], d[i][k] + b[p][k][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = t[i][j];
}
p++;
x >>= 1;
}
for (int i = 1; i <= n; i++)
if (d[i][i] < 0) return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = INF;
for (int i = 0; i < m; i++) {
int u, v, c1, c2;
scanf("%d%d%d%d", &u, &v, &c1, &c2);
a[u][v] = -c1;
a[v][u] = -c2;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) b[0][i][j] = a[i][j];
for (int p = 1; p <= 9; p++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) b[p][i][j] = a[i][j];
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
b[p][i][j] = min(b[p][i][j], b[p - 1][i][k] + b[p - 1][k][j]);
}
int low = 2, high = n, mid, ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (ok(mid - 1))
ans = mid, high = mid - 1;
else
low = mid + 1;
}
if (ans == -1)
printf("0");
else
printf("%d", ans);
}
|
#include <bits/stdc++.h>
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N, M;
void Mul(int C[][305], int A[][305], int B[][305], int N, int M, int K) {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
C[i][j] = 0x2f2f2f2f;
for (int k = 1; k <= K; k++)
if (C[i][j] > A[i][k] + B[k][j]) C[i][j] = A[i][k] + B[k][j];
}
}
int C[305][305];
void Mul(int A[][305], int B[][305], int N, int M, int K) {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
C[i][j] = 0x2f2f2f2f;
for (int k = 1; k <= K; k++)
if (C[i][j] > A[i][k] + B[k][j]) C[i][j] = A[i][k] + B[k][j];
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
A[i][j] = C[i][j];
}
}
int A[305][305];
int Power[15][305][305];
int B[305][305];
void Init() {
Get(N);
Get(M);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
if (i != j) {
A[i][j] = 0x2f2f2f2f;
}
}
for (int i = 1, U, V, W1, W2; i <= M; i++) {
Get(U);
Get(V);
Get(W1);
Get(W2);
W1 = -W1;
W2 = -W2;
if (A[U][V] > W1) A[U][V] = W1;
if (A[V][U] > W2) A[V][U] = W2;
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
Power[0][i][j] = A[i][j];
}
}
bool Judge(int A[][305]) {
for (int i = 1; i <= N; i++)
if (A[i][i] < 0) return 1;
return 0;
}
int Ans;
void Work() {
for (int i = 1; i <= 8; i++) {
Mul(Power[i], Power[i - 1], Power[i - 1], N, N, N);
}
Ans = 2;
for (int i = 8; i >= 0; i--) {
Mul(B, A, Power[i], N, N, N);
if (Judge(B) == 0) {
Ans += (1 << i);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) A[i][j] = B[i][j];
}
if (Ans > N) {
Ans = 0;
return;
}
}
}
void Output() { printf("%d\n", Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
|
#include <bits/stdc++.h>
int e[9][320][320], r[320][320], t[320][320];
void gt(int& x, int y) {
if (x < y) x = y;
}
int n, m, i, j, k, a;
int main() {
memset(e, 0xF0, sizeof(e));
memset(r, 0xF0, sizeof(r));
scanf("%d%d", &n, &m);
for (k = 0; k < m; ++k) {
scanf("%d%d", &i, &j);
--i, --j;
scanf("%d%d", &e[0][i][j], &e[0][j][i]);
}
for (i = 0; i < n; ++i) e[0][i][i] = r[i][i] = 0;
for (m = 0; m < 8; ++m)
for (k = 0; k < n; ++k)
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) gt(e[m + 1][i][j], e[m][i][k] + e[m][k][j]);
for (m = 9; m--;) {
memset(t, 0xF0, sizeof(t));
for (k = 0; k < n; ++k)
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) gt(t[i][j], r[i][k] + e[m][k][j]);
for (i = 0; i < n; ++i)
if (t[i][i] > 0) break;
if (i == n) {
a += 1 << m;
memcpy(r, t, sizeof(t));
}
}
printf("%d\n", a <= n ? a + 1 : 0);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 305;
int graph[MAXN][MAXN];
int n, m;
struct mat {
vector<vector<int>> a;
mat() {}
mat(int n) {
a.resize(n + 1);
for (int i = 1; i <= n; i++) a[i].assign(n + 1, -1e9);
for (int i = 1; i <= n; i++) a[i][i] = 0;
}
mat operator*(mat b) const {
mat r(n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++)
r.a[i][j] = max(r.a[i][j], a[i][k] + b.a[k][j]);
}
return r;
}
bool chk() {
for (int i = 1; i <= n; i++) {
if (a[i][i] > 0) return 1;
}
return 0;
}
};
mat power(mat x, int a) {
mat res(n);
while (a) {
if (a & 1) res = res * x;
x = x * x;
a >>= 1;
}
return res;
}
mat base[10];
signed main() {
cin.tie(0)->sync_with_stdio(0);
cout.tie(0);
cin >> n >> m;
base[0] = mat(n);
for (int i = 1; i <= m; i++) {
int u, v, uv, vu;
cin >> u >> v >> uv >> vu;
base[0].a[u][v] = uv;
base[0].a[v][u] = vu;
}
for (int i = 1; i < 10; i++) base[i] = base[i - 1] * base[i - 1];
if (!base[9].chk()) return cout << 0, 0;
mat cur(n);
int ans = 1;
for (int i = 9; i >= 0; i--) {
mat nxt = cur * base[i];
if (nxt.chk()) {
continue;
} else {
ans += (1 << i);
cur = nxt;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305, maxp = 10, maxval = 4000000;
int g[maxp][maxn][maxn];
int n, m;
void init() {
memset(g, 200, sizeof(g));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) g[0][i][i] = 0;
for (int i = 1, a, b, c, d; i <= m; ++i)
scanf("%d%d%d%d", &a, &b, &c, &d), g[0][a][b] = c, g[0][b][a] = d;
}
void prepare() {
for (int t = 1; (1 << t) <= n; ++t)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (g[t - 1][i][j] >= -maxval)
for (int k = 1; k <= n; ++k)
g[t][i][k] = max(g[t][i][k], g[t - 1][i][j] + g[t - 1][j][k]);
}
int r_ever[maxn][maxn], r_now[maxn][maxn], (*ever)[maxn] = r_ever,
(*now)[maxn] = r_now;
void solve() {
memset(r_ever, 200, sizeof(r_ever));
for (int i = 1; i <= n; ++i) ever[i][i] = 0;
int len = 0;
for (int t = log2(n); t >= 0; --t) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) now[i][j] = ever[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (ever[i][j] >= -maxval)
for (int k = 1; k <= n; ++k)
now[i][k] = max(now[i][k], ever[i][j] + g[t][j][k]);
bool flag = false;
for (int i = 1; i <= n; ++i)
if (now[i][i] > 0) {
flag = true;
break;
}
if (!flag) len += 1 << t, swap(ever, now);
}
if (len + 1 <= n)
printf("%d\n", len + 1);
else
puts("0");
}
int main() {
init();
prepare();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300 + 10;
const int maxm = maxn * (maxn - 1);
const int inf = 1e9 + 10;
const int maxk = 10;
int d[maxk][maxn][maxn];
int t[maxn][maxn], nd[maxn][maxn];
int n, m;
void work(int c[][maxn], int a[][maxn], int b[][maxn]) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = -inf;
for (int k = (1); k <= (n); ++k)
for (int i = (1); i <= (n); ++i) {
int j;
for (j = 1; j + 7 <= n; j += 8) {
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
((c[i][j + 1]) > (a[i][k] + b[k][j + 1])
? 0
: c[i][j + 1] = a[i][k] + b[k][j + 1]);
((c[i][j + 2]) > (a[i][k] + b[k][j + 2])
? 0
: c[i][j + 2] = a[i][k] + b[k][j + 2]);
((c[i][j + 3]) > (a[i][k] + b[k][j + 3])
? 0
: c[i][j + 3] = a[i][k] + b[k][j + 3]);
((c[i][j + 4]) > (a[i][k] + b[k][j + 4])
? 0
: c[i][j + 4] = a[i][k] + b[k][j + 4]);
((c[i][j + 5]) > (a[i][k] + b[k][j + 5])
? 0
: c[i][j + 5] = a[i][k] + b[k][j + 5]);
((c[i][j + 6]) > (a[i][k] + b[k][j + 6])
? 0
: c[i][j + 6] = a[i][k] + b[k][j + 6]);
((c[i][j + 7]) > (a[i][k] + b[k][j + 7])
? 0
: c[i][j + 7] = a[i][k] + b[k][j + 7]);
}
for (; j <= n; ++j)
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
}
}
bool judge(int a[][maxn]) {
for (int i = (1); i <= (n); ++i)
if (a[i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
d[0][i][j] = (i == j ? 0 : -inf);
}
int u, v;
for (int i = (1); i <= (m); ++i)
scanf("%d%d", &u, &v), scanf("%d%d", &d[0][u][v], &d[0][v][u]);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) t[i][j] = d[0][i][j];
for (int v = (0); v <= (8); ++v) {
work(d[v + 1], d[v], d[v]);
}
if (!judge(d[9])) {
printf("0\n");
return 0;
}
int ans = 1;
for (int v = 8; v >= 0; --v) {
work(nd, d[v], t);
if (!judge(nd)) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) t[i][j] = nd[i][j];
ans += (1 << v);
}
}
printf("%d\n", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, xc, yc, s1, s2, ans, flag;
int dp[305][305][10];
int fc[305][305], fg[305][305];
int main() {
scanf("%d %d", &N, &M);
memset(dp, 127, sizeof(dp));
for (int i = 1; i <= M; i++) {
scanf("%d %d %d %d", &xc, &yc, &s1, &s2);
dp[xc][yc][0] = -s1;
dp[yc][xc][0] = -s2;
}
for (int i = 1; i <= N; i++) dp[i][i][0] = 0;
for (int i = 1; i <= 9; i++)
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++)
for (int p = 1; p <= N; p++)
if ((dp[j][p][i - 1] != 2139062143) &&
(dp[p][k][i - 1] != 2139062143))
dp[j][k][i] = min(dp[j][k][i], dp[j][p][i - 1] + dp[p][k][i - 1]);
ans = 0;
memset(fc, 127, sizeof(fc));
for (int i = 1; i <= N; i++) fc[i][i] = 0;
for (int i = 9; i >= 0; i--) {
memset(fg, 127, sizeof(fg));
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++)
for (int p = 1; p <= N; p++)
if ((fc[j][k] != 2139062143) && (dp[k][p][i] != 2139062143))
fg[j][p] = min(fg[j][p], fc[j][k] + dp[k][p][i]);
flag = 1;
for (int j = 1; j <= N; j++)
if (fg[j][j] < 0) {
flag = 0;
break;
}
if (flag == 1) {
ans += (1 << i);
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++) fc[j][k] = fg[j][k];
}
}
if (ans > N) ans = -1;
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int TAB[300 + 5][300 + 5][10];
int CTAB[300 + 5][300 + 5];
int NCTAB[300 + 5][300 + 5];
int n, m;
int log_;
void PRZEPISZ() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) CTAB[i][j] = NCTAB[i][j];
}
bool CHECK(int mid) {
int max_;
for (int i = 20; i >= 0; i--)
if ((1 << i) & mid) {
max_ = i;
i = -1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) CTAB[i][j] = TAB[i][j][max_];
for (int k = max_ - 1; k >= 0; k--)
if ((1 << k) & mid) {
for (int a = 1; a <= n; a++)
for (int b = 1; b <= n; b++) {
NCTAB[a][b] = CTAB[a][b];
for (int mid = 1; mid <= n; mid++)
NCTAB[a][b] = max(NCTAB[a][b], CTAB[a][mid] + TAB[mid][b][k]);
}
PRZEPISZ();
}
for (int i = 1; i <= n; i++)
if (CTAB[i][i] > 0) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
log_ = log2(n);
int x, y, x_y, y_x;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) TAB[i][j][0] = -1000000000;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> x_y >> y_x;
TAB[x][y][0] = x_y;
TAB[y][x][0] = y_x;
if (x_y + y_x > 0) {
cout << 2;
return 0;
}
}
for (int k = 1; k <= log_; k++)
for (int a = 1; a <= n; a++)
for (int b = 1; b <= n; b++) {
TAB[a][b][k] = TAB[a][b][k - 1];
for (int mid = 1; mid <= n; mid++)
TAB[a][b][k] =
max(TAB[a][b][k], TAB[a][mid][k - 1] + TAB[mid][b][k - 1]);
}
int b = 1;
int e = n - 1;
if (!CHECK(n)) {
cout << 0;
return 0;
}
while (b <= e) {
int mid = (b + e) / 2;
bool b1 = CHECK(mid);
if (b1)
e = mid - 1;
else
b = mid + 1;
}
cout << b;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 305, maxk = 11;
int n, m, tot;
struct matrix {
int len, wid;
int mt[maxn][maxn];
} st, zero, tmp, now, ans[maxk];
inline int max(int a, int b) { return a > b ? a : b; }
matrix mul(matrix a, matrix b) {
matrix res = zero;
res.len = a.len, res.wid = b.wid;
for (int i = 1; i <= a.len; i++)
for (int j = 1; j <= b.wid; j++)
for (int k = 1; k <= a.wid; k++)
res.mt[i][j] = max(res.mt[i][j], a.mt[i][k] + b.mt[k][j]);
return res;
}
int main() {
scanf("%d%d", &n, &m);
zero.len = zero.wid = 0;
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++) zero.mt[i][j] = -1000000000;
st = zero;
st.len = st.wid = n;
for (int i = 1; i <= n; i++) st.mt[i][i] = 0;
for (int i = 1; i <= m; i++) {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
st.mt[x][y] = a, st.mt[y][x] = b;
}
ans[0] = st;
for (int i = 1; i <= 10; i++) ans[i] = mul(ans[i - 1], ans[i - 1]);
now = zero;
now.len = now.wid = n;
for (int i = 1; i <= n; i++) now.mt[i][i] = 0;
for (int i = 10; i >= 0; i--) {
int flg = 1;
tmp = mul(now, ans[i]);
for (int j = 1; j <= n; j++)
if (tmp.mt[j][j] > 0) {
flg = 0;
break;
}
if (flg == 0) continue;
tot += (1 << i);
now = tmp;
}
printf("%d\n", tot >= n ? 0 : tot + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in[100];
int dist[9][311][311], res[311][311], t[311][311];
int main() {
int x, y, a, b, now, ans, i, j, k, l, n, m;
while (cin >> n >> m) {
memset(dist, 0xE0, sizeof(dist));
memset(res, 0xE0, sizeof(res));
for (i = 0; i < n; ++i) dist[0][i][i] = res[i][i] = 0;
for (i = 0; i < m; ++i) {
scanf("%d%d%d%d", &x, &y, &a, &b);
dist[0][x - 1][y - 1] = a, dist[0][y - 1][x - 1] = b;
}
for (i = 1; i < 9; ++i)
for (j = 0; j < n; ++j)
for (k = 0; k < n; ++k)
for (l = 0; l < n; ++l) {
dist[i][k][l] =
max(dist[i][k][l], dist[i - 1][k][j] + dist[i - 1][j][l]);
}
ans = 0, now = (1 << 8);
for (i = 8; i >= 0; i--) {
memset(t, 0xE0, sizeof(t));
for (j = 0; j < n; ++j)
for (k = 0; k < n; ++k)
for (l = 0; l < n; ++l) {
t[k][l] = max(t[k][l], res[k][j] + dist[i][j][l]);
}
for (j = 0; j < n; ++j)
if (t[j][j] > 0) break;
if (j == n) {
ans += now;
memcpy(res, t, sizeof(t));
}
now >>= 1;
}
if (ans >= n)
cout << 0 << endl;
else
cout << ans + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
int n, m, ans = 1;
int d[10][N][N];
int f[N][N], tmp[N][N];
int lg[N];
void init() {
for (int i = 1; i <= n; i++) {
lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
}
memset(d, -INF, sizeof d);
memset(f, -INF, sizeof f);
for (int i = 1; i <= n; i++) {
d[0][i][i] = 0;
f[i][i] = 0;
}
}
void floyd() {
for (int s = 1; s <= lg[n]; s++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[s][i][j] = max(d[s][i][j], d[s - 1][i][k] + d[s - 1][k][j]);
}
}
}
}
}
void solve() {
cin >> n >> m;
init();
while (m--) {
int u, v;
cin >> u >> v;
cin >> d[0][u][v] >> d[0][v][u];
}
floyd();
for (int s = lg[n]; ~s; s--) {
memset(tmp, -INF, sizeof tmp);
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
tmp[i][j] = max(tmp[i][j], f[i][k] + d[s][k][j]);
}
}
}
bool flag = 0;
for (int i = 1; i <= n; i++) {
if (tmp[i][i] > 0) {
flag = 1;
break;
}
}
if (flag)
continue;
else {
ans += (1 << s);
memcpy(f, tmp, sizeof tmp);
}
}
if (ans > n)
cout << "0\n";
else
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int n;
int mul(int a[300][300], int b[300][300]) {
int u, v, w, t[300][300];
for (u = 0; u < n; u++)
for (v = 0; v < n; v++) {
t[u][v] = -1000000000;
for (w = 0; w < n; w++) t[u][v] = max(t[u][v], a[u][w] + b[w][v]);
}
memcpy(a, t, sizeof(t));
}
int main() {
int m;
scanf("%d%d", &n, &m);
int i, u, v, a[300][300];
for (u = 0; u < n; u++)
for (v = 0; v < n; v++) a[u][v] = u == v ? 0 : -1000000000;
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
scanf("%d%d", &a[u][v], &a[v][u]);
}
int l = 2, h = n + 1;
while (l < h) {
m = (l + h) / 2;
int b[300][300];
memcpy(b, a, sizeof(b));
int c[300][300];
for (u = 0; u < n; u++)
for (v = 0; v < n; v++) c[u][v] = u == v ? 0 : -1000000000;
i = m;
while (i) {
if (i & 1) mul(c, b);
mul(b, b);
i >>= 1;
}
for (u = 0; u < n; u++)
if (c[u][u] > 0) break;
if (u != n)
h = m;
else
l = m + 1;
}
if (l == n + 1)
puts("0");
else
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int n, m;
struct mat {
int a[305][305];
} f[15];
inline int ln(int x) {
int res = 0, i = 1;
while (i <= x) {
i <<= 1;
res++;
}
return res - 1;
}
inline mat mul(mat u, mat v) {
mat res;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) res.a[i][j] = -inf;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) res.a[i][j] = 0;
for (int k = 1; k <= n; k++) {
if (u.a[i][k] != -inf && v.a[k][j] != -inf)
res.a[i][j] = max(res.a[i][j], u.a[i][k] + v.a[k][j]);
}
}
}
return res;
}
inline bool check(mat x) {
for (int i = 1; i <= n; i++)
if (x.a[i][i] > 0) return 1;
return 0;
}
inline void print(mat x) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d ", x.a[i][j]);
puts("");
}
return;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
if (i != j)
f[0].a[i][j] = -inf;
else
f[0].a[i][j] = 0;
for (int i = 1; i <= m; i++) {
int x, y, z, k;
scanf("%d%d%d%d", &x, &y, &z, &k);
f[0].a[x][y] = z;
f[0].a[y][x] = k;
}
for (int i = 1; i <= ln(n) + 1; i++) f[i] = mul(f[i - 1], f[i - 1]);
mat e = f[0];
int ans = 1;
for (int i = ln(n); i >= 0; i--) {
mat t = mul(e, f[i]);
if (!check(t)) {
e = t;
ans += (1 << i);
}
}
e = mul(e, f[0]);
ans++;
if (check(e))
printf("%d\n", ans);
else
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
int n, m, x, y, tmp, ans;
struct mat {
int v[305][305];
} g[9], p, q;
mat operator*(mat a, mat b) {
mat res;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
res.v[i][j] = a.v[i][j];
if (b.v[i][j] < res.v[i][j]) res.v[i][j] = b.v[i][j];
for (int k = 1; k <= n; k++)
if (a.v[i][k] + b.v[k][j] > res.v[i][j])
res.v[i][j] = a.v[i][k] + b.v[k][j];
}
return res;
}
void clear(mat& a) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a.v[i][j] = i == j ? 0 : -1 << 22;
}
bool check(mat a) {
for (int i = 1; i <= n; i++)
if (a.v[i][i] > 0) return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[0].v[i][j] = -1 << 22;
while (m--) {
scanf("%d%d", &x, &y);
scanf("%d%d", &g[0].v[x][y], &g[0].v[y][x]);
}
for (int t = 1; t <= 8; t++) g[t] = g[t - 1] * g[t - 1];
clear(p);
tmp = 0;
ans = 0;
for (int i = 8; i >= 0; i--) {
q = p * g[i];
if (check(q))
ans = tmp + (1 << i);
else
tmp = tmp + (1 << i), p = q;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 305, oo = 1e18, LOG = 10;
long long n, m, g[N][N];
struct Matrix {
vector<vector<long long>> mat;
Matrix() {
mat.assign(n + 5, vector<long long>(n + 5, -oo));
for (long long i = 1; i <= n; ++i) mat[i][i] = 0;
}
} F[LOG];
Matrix operator+(const Matrix &a, const Matrix &b) {
Matrix res;
for (long long k = 1; k <= n; ++k) {
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
res.mat[i][j] = max(res.mat[i][j], a.mat[i][k] + b.mat[k][j]);
}
}
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) g[i][j] = -oo;
}
for (long long i = 0; i < LOG; ++i) F[i] = Matrix();
for (long long i = 1; i <= m; ++i) {
long long u, v;
cin >> u >> v;
cin >> g[u][v] >> g[v][u];
F[0].mat[u][v] = g[u][v];
F[0].mat[v][u] = g[v][u];
}
for (long long i = 1; i <= 9; ++i) F[i] = F[i - 1] + F[i - 1];
long long res = 0;
Matrix cur;
for (long long i = 9; i >= 0; --i) {
Matrix tmp = cur + F[i];
bool f = false;
for (long long j = 1; j <= n; ++j)
if (tmp.mat[j][j] > 0) f = true;
if (!f) {
if (i == 9) {
cout << 0 << endl;
return 0;
}
cur = tmp, res += (1 << i);
}
}
cout << res + 1 << endl;
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300 + 10;
const int maxm = maxn * (maxn - 1);
const int inf = 1e9 + 10;
const int maxk = 10;
int d[maxk][maxn][maxn];
int t[maxn][maxn], nd[maxn][maxn];
int n, m;
void work(int c[][maxn], int a[][maxn], int b[][maxn]) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = -inf;
for (int k = (1); k <= (n); ++k)
for (int i = (1); i <= (n); ++i) {
int j;
for (j = 1; j + 4 <= n; j += 4) {
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
((c[i][j + 1]) > (a[i][k] + b[k][j + 1])
? 0
: c[i][j + 1] = a[i][k] + b[k][j + 1]);
((c[i][j + 2]) > (a[i][k] + b[k][j + 2])
? 0
: c[i][j + 2] = a[i][k] + b[k][j + 2]);
((c[i][j + 3]) > (a[i][k] + b[k][j + 3])
? 0
: c[i][j + 3] = a[i][k] + b[k][j + 3]);
}
for (; j <= n; ++j)
((c[i][j]) > (a[i][k] + b[k][j]) ? 0 : c[i][j] = a[i][k] + b[k][j]);
}
}
bool judge(int a[][maxn]) {
for (int i = (1); i <= (n); ++i)
if (a[i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
d[0][i][j] = (i == j ? 0 : -inf);
}
int u, v;
for (int i = (1); i <= (m); ++i)
scanf("%d%d", &u, &v), scanf("%d%d", &d[0][u][v], &d[0][v][u]);
memcpy(t, d[0], sizeof t);
for (int v = (0); v <= (8); ++v) work(d[v + 1], d[v], d[v]);
if (!judge(d[9])) {
printf("0\n");
return 0;
}
int ans = 1;
for (int v = 8; v >= 0; --v) {
work(nd, d[v], t);
if (!judge(nd)) {
memcpy(t, nd, sizeof t);
ans += (1 << v);
}
}
printf("%d\n", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[11][333][333], d[333][333], ans[333][333], b[333][333];
inline void checkmax(int &x, int y) {
if (x < y) x = y;
}
void mul(int c[][333], int a[][333], int b[][333]) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
c[i][j] = -1000000000;
for (int k = 1; k <= n; ++k)
checkmax(c[i][j], a[i][k] + b[k][j]),
checkmax(c[i][j], b[i][k] + a[k][j]);
}
}
bool cks() {
for (int i = 1; i <= n; ++i)
if (d[i][i] > 0) return 1;
return 0;
}
void output(int a[][333]) {
for (int i = 1; i <= n; ++i, puts("")) {
for (int j = 1; j <= n; ++j)
if (a[i][j] < -1000000000 / 2)
printf(" oo");
else
printf("%3d", a[i][j]);
}
puts("");
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
a[0][i][j] = (i == j) ? 0 : -1000000000;
ans[i][j] = (i == j) ? 0 : -1000000000;
}
for (int i = 1; i <= m; ++i) {
int x, y, w, z;
scanf("%d%d%d%d", &x, &y, &w, &z);
a[0][x][y] = w;
a[0][y][x] = z;
}
int T = 0, as = 0;
for (int i = 1; (1 << i) <= n; ++i) {
++T;
mul(a[i], a[i - 1], a[i - 1]);
}
for (int i = T; i >= 0; --i) {
memcpy(b, ans, sizeof b);
mul(d, b, a[i]);
if (!cks()) {
mul(ans, b, a[i]);
as += (1 << i);
}
}
mul(d, ans, a[0]);
if (cks())
printf("%d\n", as + 1);
else
puts("0");
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, N = 300;
int n, m;
struct Matrix {
int M[N][N];
Matrix() {
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) M[i][j] = -inf;
for (int i = 0; i < N; ++i) M[i][i] = 0;
}
Matrix operator*(Matrix &b) {
Matrix c;
for (int k = 0; k < N; ++k)
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
c.M[i][j] = max(c.M[i][j], M[i][k] + b.M[k][j]);
return c;
}
} adj[17];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v, From, Go;
cin >> u >> v >> From >> Go;
--u, --v;
adj[0].M[u][v] = From;
adj[0].M[v][u] = Go;
}
for (int i = 1; i < 17; ++i) adj[i] = adj[i - 1] * adj[i - 1];
int pos = 1;
Matrix cur = adj[0];
for (int i = 16; i >= 0; --i) {
Matrix d = cur * adj[i];
bool ok = 0;
for (int j = 0; j < n; ++j)
if (d.M[j][j] > 0) ok = 1;
if (ok == 1) continue;
pos += (1 << i), cur = d;
}
cur = cur * adj[0];
for (int i = 0; i < n; ++i)
if (cur.M[i][i] > 0) return printf("%d\n", pos + 1), 0;
printf("0\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
const long long inf = 1e18;
int n, m, ans;
long long e[11][N][N], dis[N][N], cp[N][N];
bool flcyc;
void chkma(long long &x, long long y) { x = x > y ? x : y; }
void init() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) e[0][i][j] = dis[i][j] = -inf;
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1, u, v, w, w2; i <= m; i++)
scanf("%d%d%d%d", &u, &v, &w, &w2), e[0][u][v] = w, e[0][v][u] = w2;
for (int t = 1; t <= 10; t++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) e[t][i][j] = e[t - 1][i][j];
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
chkma(e[t][i][j], e[t - 1][i][k] + e[t - 1][k][j]);
}
for (int t = 10; ~t; t--) {
memcpy(cp, dis, sizeof(cp));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) chkma(cp[i][j], e[t][i][j]);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) chkma(cp[i][j], dis[i][k] + e[t][k][j]);
bool fl = false;
for (int i = 1; i <= n; i++)
if (cp[i][i] > 0) {
fl = flcyc = true;
break;
}
if (!fl) memcpy(dis, cp, sizeof(dis)), ans += (1 << t);
}
if (!flcyc)
puts("0");
else
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
long long read() {
long long x = 0;
long long f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
return x;
}
long long n, m;
struct matrix {
long long s[315][315];
void inti() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) s[i][j] = -0x3f3f3f3f;
return;
}
matrix operator*(matrix b) const {
matrix f;
f.inti();
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
f.s[i][j] = max(f.s[i][j], s[i][k] + b.s[k][j]);
return f;
}
} t[10], now, p;
int main() {
n = read(), m = read();
t[0].inti();
for (int i = 1; i <= n; i++) t[0].s[i][i] = 0;
for (int i = 1; i <= m; i++) {
long long u = read(), v = read();
t[0].s[u][v] = read();
t[0].s[v][u] = read();
}
for (int i = 1; i < 10; i++) t[i] = t[i - 1] * t[i - 1];
now.inti(), p.inti();
for (int i = 1; i <= n; i++) now.s[i][i] = 0;
long long ans = 0;
for (int i = 10 - 1; ~i; i--) {
p = now * t[i];
bool flag = 0;
for (int j = 1; j <= n; j++)
if (p.s[j][j] > 0) {
flag = 1;
break;
}
if (flag) continue;
ans += (1 << i), now = p;
}
if (ans > n)
puts("0");
else
printf("%lld", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef int matriz[303][303];
int n, m;
matriz M, b1, b2;
matriz *B, *A;
inline void mult(matriz *C) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int menor = 1000000000;
for (int k = 0; k < n; k++) {
int tt = (*B)[i][k] + (*C)[k][j];
menor = (menor < tt ? menor : tt);
}
(*A)[i][j] = menor;
}
matriz *aux = B;
B = A;
A = aux;
}
inline void pow(int k) {
if (k == 1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) (*B)[i][j] = M[i][j];
return;
}
if (k & 1) {
pow(k - 1);
mult(&M);
return;
}
pow(k / 2);
mult(B);
return;
}
inline bool blza(int k) {
pow(k);
for (int i = 0; i < n; i++)
if ((*B)[i][i] < 0) return true;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) M[i][j] = 1000000000;
M[i][i] = 0;
}
while (m--) {
int a, b, w1, w2;
scanf("%d %d %d %d", &a, &b, &w1, &w2);
a--;
b--;
M[a][b] = -w1;
M[b][a] = -w2;
}
int ini = 2, fim = n, resp = 1000000000;
B = &b1;
A = &b2;
while (ini <= fim) {
int meio = (ini + fim) / 2;
if (blza(meio)) {
resp = meio;
fim = meio - 1;
} else
ini = meio + 1;
}
printf("%d\n", resp > n ? 0 : resp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 7;
const int oo = 1e9;
int n, m, c1, c2, ma[301][301], i, j, vis[304];
vector<vector<int> > cache[305];
vector<vector<int> > operator*(vector<vector<int> > a, vector<vector<int> > b) {
int n = (int)a.size();
int m = (int)b.size();
int p = (int)b[0].size();
vector<vector<int> > c;
c.resize(n);
for (int i = 0; i < n; i++) {
c[i].assign(p, 0);
for (int j = 0; j < p; j++) {
c[i][j] = -oo;
for (int k = 0; k < m; k++) {
c[i][j] = max(c[i][j], a[i][k] + b[k][j]);
}
}
}
return c;
}
vector<vector<int> > id(int n) {
vector<vector<int> > a;
a.resize(n);
for (int i = 0; i < n; i++) {
a[i].assign(n, -oo);
a[i][i] = 0;
}
return a;
}
vector<vector<int> > matrixExp(vector<vector<int> > a, int n) {
if (vis[n]) return cache[n];
vis[n] = 1;
if (n == 0) return id(a.size());
vector<vector<int> > c = matrixExp(a, n / 2);
c = c * c;
if (n % 2 != 0) c = c * a;
return cache[n] = c;
}
int ok(vector<vector<int> > A, int k) {
A = matrixExp(A, k);
for (int i = 0; i < A.size(); i++) {
if (A[i][i] > 0) return 1;
}
return 0;
}
bool check(vector<vector<int> > m) {
for (int i = 0; i < m.size(); i++) {
if (m[i][i] > 0) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
std::cin >> n >> m;
vector<vector<int> > M;
M.resize(n, std::vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
M[i][j] = -oo;
}
M[i][i] = 0;
}
for (int k = 0; k < m; k++) {
std::cin >> i >> j >> c1 >> c2;
--i, --j;
M[i][j] = c1;
M[j][i] = c2;
}
int res = 0;
vector<vector<int> > curm = id(n);
for (int i = 9; i >= 0; i--) {
vector<vector<int> > tmpm(M);
for (int j = 0; j < i; j++) tmpm = tmpm * tmpm;
if (!check(tmpm * curm)) curm = curm * tmpm, res += (1 << i);
}
if (res == (1 << 10) - 1) res = -1;
std::cout << res + 1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300 + 10;
int N, M;
int tmp[MAX_N][MAX_N];
int ret[MAX_N][MAX_N];
int p[10][MAX_N][MAX_N];
int a[MAX_N][MAX_N];
void Init() {
int s, t;
memset(a, 200, sizeof a);
scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) {
scanf("%d%d", &s, &t);
s--, t--;
scanf("%d%d", &a[s][t], &a[t][s]);
}
for (int i = 0; i < N; ++i) a[i][i] = 0;
memset(p, 200, sizeof p);
memcpy(p[0], a, sizeof a);
for (int now = 1; now < 10; ++now) {
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
for (int k = 0; k < N; ++k)
p[now][i][j] = max(p[now][i][j], p[now - 1][i][k] + p[now - 1][k][j]);
}
}
void Solve() {
int ans = 0, flag;
memset(ret, 200, sizeof ret);
for (int i = 0; i < N; ++i) ret[i][i] = 0;
for (int now = 9; now >= 0; --now) {
memset(tmp, 200, sizeof tmp);
flag = 0;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j)
for (int k = 0; k < N; ++k)
tmp[i][j] = max(tmp[i][j], ret[i][k] + p[now][k][j]);
if (tmp[i][i] > 0) flag = 1;
}
if (!flag) {
memcpy(ret, tmp, sizeof tmp);
ans += 1 << now;
}
}
if (ans + 1 > N)
puts("0");
else
printf("%d\n", ans + 1);
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 333;
const int Q = 20;
const int inf = 1e9;
int n, m, d[N][N][Q], f[Q];
bool comb(int x, int y, int z) {
int i, j, k;
for (i = 1; i <= n; i = i + 1) {
for (j = 1; j <= n; j = j + 1) d[i][j][x] = -inf;
d[i][i][x] = 0;
}
for (i = 1; i <= n; i = i + 1)
for (j = 1; j <= n; j = j + 1)
for (k = 1; k <= n; k = k + 1)
if (d[i][k][x] < d[i][j][y] + d[j][k][z])
d[i][k][x] = d[i][j][y] + d[j][k][z];
for (i = 1; i <= n; i = i + 1)
if (d[i][i][x] > 0) return 0;
f[x] = f[y] + f[z];
return 1;
}
int main() {
int i, j, k, x, y;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i = i + 1) {
for (j = 1; j <= n; j = j + 1) d[i][j][0] = -inf;
d[i][i][0] = 0;
}
while (m--) {
scanf("%d%d%d%d", &i, &j, &x, &y);
d[i][j][0] = x, d[j][i][0] = y;
}
f[0] = 1;
for (i = 0, j = 0; f[i] <= n; i = i + 1) {
while (j >= 0 && !comb(i + 1, i, j)) {
j--;
}
if (j < 0) {
printf("%d", f[i] + 1);
return 0;
}
if (i == j)
j++;
else
j--;
}
printf("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 300 + 5;
const int INF = (1 << 29);
vector<vector<int> > tmp, res[10], g, mat;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i].push_back(INF);
for (int i = 0; i < m; i++) {
int u, v, c1, c2;
cin >> u >> v >> c1 >> c2;
u--;
v--;
g[u][v] = -c1;
g[v][u] = -c2;
}
res[0] = g;
for (int l = 1; l < 10; l++) {
res[l] = res[l - 1];
for (int x = 0; x < n; x++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
res[l][i][j] = min(res[l][i][j], res[l - 1][i][x] + res[l - 1][x][j]);
}
mat = g;
int ans = 1;
for (int l = 9; l >= 0; l--) {
tmp = mat;
for (int x = 0; x < n; x++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
tmp[i][j] = min(tmp[i][j], mat[i][x] + res[l][x][j]);
bool flag = false;
for (int i = 0; i < n; i++)
if (tmp[i][i] < 0) {
flag = true;
break;
}
if (!flag) {
ans += (1 << l);
mat = tmp;
}
}
if (ans == (1 << 10))
cout << 0 << endl;
else
cout << ans + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 310, oo = 1 << 28;
long long bway[10][N][N], last[N][N], n, m;
long long ans(long long b, long long e) {
if (b + 1 == e) return e;
long long pow = 9, temp[N][N], res = 0;
for (long long i = 0; i < N; ++i)
for (long long j = 0; j < N; ++j) temp[i][j] = -oo;
while ((1 << pow) + b >= e) --pow;
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j)
for (long long k = 1; k <= n; ++k)
temp[i][j] = ((temp[i][j]) > (last[i][k] + bway[pow][k][j])
? (temp[i][j])
: (last[i][k] + bway[pow][k][j]));
for (long long i = 1; i <= n; ++i)
res = ((res) > (temp[i][i]) ? (res) : (temp[i][i]));
if (res > 0) return ans(b, b + (1 << pow));
for (long long i = 0; i < N; ++i)
for (long long j = 0; j < N; ++j) last[i][j] = temp[i][j];
return ans(b + (1 << pow), e);
}
int main() {
for (long long p = 0; p < 10; ++p)
for (long long i = 0; i < N; ++i)
for (long long j = 0; j < N; ++j) bway[p][i][j] = -oo;
for (long long i = 0; i < N; ++i) bway[0][i][i] = 0;
cin >> n >> m;
for (long long i = 1; i <= m; ++i) {
long long x, y;
cin >> x >> y;
cin >> bway[0][x][y] >> bway[0][y][x];
}
for (long long i = 0; i < N; ++i)
for (long long j = 0; j < N; ++j) last[i][j] = bway[0][i][j];
for (long long p = 1; p < 10; ++p)
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j)
for (long long k = 1; k <= n; ++k)
bway[p][i][j] =
((bway[p][i][j]) > (bway[p - 1][i][k] + bway[p - 1][k][j])
? (bway[p][i][j])
: (bway[p - 1][i][k] + bway[p - 1][k][j]));
cout << ans(1, n + 1) % (n + 1) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct MAT {
int A[303][303];
} mat[15], Sol, lmat, rmat;
int n, T;
int num[19];
void View(MAT &m) {
int i, j;
for (i = 1; i <= 4; i++) {
for (j = 1; j <= 4; j++) {
printf(" %d", m.A[i][j]);
}
printf("\n");
}
printf("\n");
}
MAT &operator*(MAT &m1, MAT &m2) {
int i, j, k;
for (i = 1; i <= 300; i++) {
for (j = 1; j <= 300; j++) {
Sol.A[i][j] = ((m1.A[i][j]) > (m2.A[i][j]) ? (m1.A[i][j]) : (m2.A[i][j]));
for (k = 1; k <= 300; k++) {
Sol.A[i][j] = ((Sol.A[i][j]) > (m1.A[i][k] + m2.A[k][j])
? (Sol.A[i][j])
: (m1.A[i][k] + m2.A[k][j]));
}
}
}
return Sol;
}
int ok(int id) {
int i;
for (i = 1; i <= n; i++) {
if (mat[id].A[i][i] > 0) return 1;
}
return 0;
}
int main() {
int X[2][4];
int i, m, j, k;
scanf("%d %d", &n, &m);
for (i = 1; i <= 300; i++)
for (j = 1; j <= 300; j++) {
mat[0].A[i][j] = -10000000;
}
while (m--) {
scanf("%d %d", &i, &j);
scanf("%d %d", &mat[0].A[i][j], &mat[0].A[j][i]);
X[m % 2][0] = i;
X[m % 2][1] = j;
X[m % 2][2] = mat[0].A[i][j];
X[m % 2][3] = mat[0].A[j][i];
}
num[0] = 0;
int hi = -1, lo = -1;
for (i = 1; i <= 9; i++) {
num[i] = 2 * num[i - 1] + 1;
mat[i] = mat[i - 1] * mat[i - 1];
if (ok(i)) {
hi = num[i];
lo = num[i - 1];
lmat = mat[i - 1];
rmat = mat[i];
break;
}
}
if (hi == -1) {
printf("0\n");
return 0;
}
int mid;
for (i = i - 2; i >= 0; i--) {
mat[10] = lmat * mat[i];
mid = (lo + hi) / 2;
if (ok(10)) {
hi = mid;
} else {
lo = mid;
lmat = mat[10];
}
}
printf("%d\n", hi + 1);
return 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int g[11][312][312];
int f[312][312], s[312][312];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) g[0][i][j] = 1000002012;
for (int i = 1; i <= M; ++i) {
int x, y, c1, c2;
scanf("%d%d%d%d", &x, &y, &c1, &c2);
g[0][x][y] = -c1;
g[0][y][x] = -c2;
}
for (int p = 1; p <= 10; ++p) {
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) g[p][i][j] = g[p - 1][i][j];
for (int k = 1; k <= N; ++k)
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j)
g[p][i][j] = min(g[p - 1][i][k] + g[p - 1][k][j], g[p][i][j]);
}
bool flag = 0;
for (int i = 1; i <= N; ++i)
if (g[10][i][i] < 0) flag = 1;
if (!flag) {
puts("0");
return 0;
}
int ans = 0;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j)
if (i != j)
f[i][j] = 1000002012;
else
f[i][j] = 0;
int T = 2048;
for (int p = 10; p >= 0; --p) {
T = T >> 1;
bool flag = 0;
for (int i = 1; i <= N; ++i)
if (g[p][i][i] < 0) flag = 1;
if (flag) continue;
memcpy(s, f, sizeof(f));
for (int i = 1; i <= N; ++i)
for (int k = 1; k <= N; ++k)
for (int j = 1; j <= N; ++j)
s[i][j] = min(f[i][k] + g[p][k][j], s[i][j]);
flag = 0;
for (int i = 1; i <= N; ++i)
if (s[i][i] < 0) flag = 1;
if (!flag) {
ans += T;
memcpy(f, s, sizeof(s));
}
}
cout << ans + 1;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.