problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p03166
|
C++
|
Time Limit Exceeded
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 100100;
int n, m, dp[MAXN];
vector<int> g[MAXN];
int dfs(int node) {
if (dp[node] != -1)
return dp[node];
int best = 0;
for (int x : g[node])
best = max(best, 1 + dfs(x));
return best;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
}
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 1; i <= n; i++)
if (dp[i] == -1)
ans = max(ans, dfs(i));
cout << ans;
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 100100;
int n, m, dp[MAXN];
vector<int> g[MAXN];
int dfs(int node) {
if (dp[node] != -1)
return dp[node];
int best = 0;
for (int x : g[node])
best = max(best, 1 + dfs(x));
return dp[node] = best;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
}
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 1; i <= n; i++)
if (dp[i] == -1)
ans = max(ans, dfs(i));
cout << ans;
}
|
replace
| 12 | 13 | 12 | 13 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
vvi G(100100, vi(0));
vi dp(100100, -1);
int func(int v) {
if (dp.at(v) != -1)
return dp.at(v);
int res = 0;
for (auto x : G.at(v)) {
chmax(res, func(x) + 1);
}
return res;
}
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G.at(x).push_back(y);
}
int result = 0;
for (int i = 0; i < N; i++) {
chmax(result, func(i));
}
cout << result << endl;
}
|
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
vvi G(100100, vi(0));
vi dp(100100, -1);
int func(int v) {
if (dp.at(v) != -1)
return dp.at(v);
int res = 0;
for (auto x : G.at(v)) {
chmax(res, func(x) + 1);
}
return dp.at(v) = res;
}
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G.at(x).push_back(y);
}
int result = 0;
for (int i = 0; i < N; i++) {
chmax(result, func(i));
}
cout << result << endl;
}
|
replace
| 38 | 39 | 38 | 39 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 5;
int n, m;
vector<int> a[maxn];
int f[maxn];
int dp(int u) {
if (f[u] != -1)
return f[u];
f[u] = 0;
for (int v : a[u])
f[u] = max(f[u], dp(v) + 1);
return f[u];
}
int main() {
#ifdef NTMA
freopen("abc.inp", "r", stdin);
#endif
memset(f, 255, sizeof(f));
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
}
int ans = 0;
for (int i = 1; i <= n; ++i)
ans = max(ans, dp(i));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m;
vector<int> a[maxn];
int f[maxn];
int dp(int u) {
if (f[u] != -1)
return f[u];
f[u] = 0;
for (int v : a[u])
f[u] = max(f[u], dp(v) + 1);
return f[u];
}
int main() {
#ifdef NTMA
freopen("abc.inp", "r", stdin);
#endif
memset(f, 255, sizeof(f));
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
}
int ans = 0;
for (int i = 1; i <= n; ++i)
ans = max(ans, dp(i));
cout << ans;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 112345;
int n, m;
vector<int> adj[MAXN];
int pd[MAXN];
int rec(int cur) {
if (pd[cur] != -1)
return pd[cur];
int rtn = 0;
for (int i = 0; i < adj[cur].size(); i++) {
rtn = max(1 + rec(adj[cur][i]), rtn);
}
return rtn;
}
int main() {
memset(pd, -1, sizeof(pd));
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
}
int resp = 0;
for (int i = 1; i <= n; i++)
resp = max(resp, rec(i));
cout << resp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 112345;
int n, m;
vector<int> adj[MAXN];
int pd[MAXN];
int rec(int cur) {
if (pd[cur] != -1)
return pd[cur];
int rtn = 0;
for (int i = 0; i < adj[cur].size(); i++) {
rtn = max(1 + rec(adj[cur][i]), rtn);
}
return pd[cur] = rtn;
}
int main() {
memset(pd, -1, sizeof(pd));
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
}
int resp = 0;
for (int i = 1; i <= n; i++)
resp = max(resp, rec(i));
cout << resp << endl;
return 0;
}
|
replace
| 19 | 20 | 19 | 20 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define hash sodnf9843bsd
#define ll long long
#define INF (1 << 29)
#define INFF 0x7fffffff
#define LINF (1ll << 60)
#define LINFF 0x7fffffffffffffff
#define PI 3.14159265359
#define _fi(n) for (int i = 0; i < n; i++)
#define _fj(n) for (int j = 0; j < n; j++)
#define _fk(n) for (int k = 0; k < n; k++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define YESNO(ans) cout << (ans ? "YES" : "NO") << endl
#define prec(x) cout << fixed << setprecision(x)
#define pqueue priority_queue
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define endl '\n'
const int maxn = 1e5;
vector<int> adj[maxn];
int dp[maxn + 7] = {};
int dfs(int a) {
if (dp[a] == 0) {
dp[a] = 1;
for (int b : adj[a]) {
dp[a] = max(dp[a], dfs(b) + 1);
}
}
return dp[a];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
_fi(m) {
int a, b;
cin >> a >> b;
adj[a].pb(b);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dfs(i));
}
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define hash sodnf9843bsd
#define ll long long
#define INF (1 << 29)
#define INFF 0x7fffffff
#define LINF (1ll << 60)
#define LINFF 0x7fffffffffffffff
#define PI 3.14159265359
#define _fi(n) for (int i = 0; i < n; i++)
#define _fj(n) for (int j = 0; j < n; j++)
#define _fk(n) for (int k = 0; k < n; k++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define YESNO(ans) cout << (ans ? "YES" : "NO") << endl
#define prec(x) cout << fixed << setprecision(x)
#define pqueue priority_queue
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define endl '\n'
const int maxn = 1e5;
vector<int> adj[maxn + 7];
int dp[maxn + 7] = {};
int dfs(int a) {
if (dp[a] == 0) {
dp[a] = 1;
for (int b : adj[a]) {
dp[a] = max(dp[a], dfs(b) + 1);
}
}
return dp[a];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
_fi(m) {
int a, b;
cin >> a >> b;
adj[a].pb(b);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dfs(i));
}
cout << ans - 1 << endl;
return 0;
}
|
replace
| 28 | 29 | 28 | 29 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A[100001];
int dp[100001];
bool visit[100001];
int dfs(int x) {
int mx = 0;
visit[x] = false;
if (A[x].size() == 0) {
dp[x] = 0;
return 0;
}
for (int i = 0; i < A[x].size(); i++)
if (visit[A[x][i]] == false)
mx = max(mx, dfs(A[x][i]));
else
mx = max(mx, dp[A[x][i]]);
dp[x] = mx + 1;
return mx + 1;
}
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
A[a].push_back(b);
}
memset(visit, false, sizeof visit);
memset(dp, -1, sizeof dp);
for (int i = 0; i <= n; i++) {
if (visit[i] == false)
dfs(i);
}
sort(dp, dp + n + 1, greater<int>());
cout << dp[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A[100001];
int dp[100001];
bool visit[100001];
int dfs(int x) {
int mx = 0;
visit[x] = true;
if (A[x].size() == 0) {
dp[x] = 0;
return 0;
}
for (int i = 0; i < A[x].size(); i++)
if (visit[A[x][i]] == false)
mx = max(mx, dfs(A[x][i]));
else
mx = max(mx, dp[A[x][i]]);
dp[x] = mx + 1;
return mx + 1;
}
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
A[a].push_back(b);
}
memset(visit, false, sizeof visit);
memset(dp, -1, sizeof dp);
for (int i = 0; i <= n; i++) {
if (visit[i] == false)
dfs(i);
}
sort(dp, dp + n + 1, greater<int>());
cout << dp[0];
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <stdint.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
#define endl '\n'
#define w(x) \
int x; \
cin >> x; \
while (x-- > 0)
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
vector<vector<int>> v(100011);
// bool visited[10001]={false};
int dp[100011];
int n, m;
int ans = 0;
int dfs(int id) {
if (v[id].size() == 0)
return 0;
if (dp[id] != -1)
return dp[id];
int t = -1;
for (int i : v[id])
t = max(t, dfs(i) + 1);
ans = max(ans, t);
return dp[id] = t;
}
void mysol() {
memset(dp, -1, sizeof dp);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].pb(b);
}
for (int i = 1; i <= n; i++) {
dfs(i);
}
cout << ans;
}
int32_t main() {
fast();
// w(t)
{ mysol(); }
return 0;
}
|
#include <bits/stdc++.h>
#include <stdint.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
#define endl '\n'
#define w(x) \
int x; \
cin >> x; \
while (x-- > 0)
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
vector<vector<int>> v(100011);
// bool visited[10001]={false};
int dp[100011];
int n, m;
int ans = 0;
int dfs(int id) {
if (v[id].size() == 0)
return 0;
if (dp[id] != -1)
return dp[id];
int t = -1;
for (int i : v[id])
t = max(t, dfs(i) + 1);
ans = max(ans, t);
return dp[id] = t;
}
void mysol() {
memset(dp, -1, sizeof dp);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].pb(b);
}
for (int i = 1; i <= n; i++) {
dfs(i);
}
cout << ans;
}
int32_t main() {
// fast();
// w(t)
{ mysol(); }
return 0;
}
|
replace
| 53 | 55 | 53 | 55 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int child[100001];
int marker[100001];
int maximumm = 0;
int dfs(int head, vector<int> v[]) {
child[head] = 1;
int maxi = 0;
for (int i = 0; i < v[head].size(); i++) {
// maxi=0;
if (marker[v[head][i]] == 0) {
int x = dfs(v[head][i], v);
if (x > maxi)
maxi = x;
} else {
int k = child[v[head][i]];
if (k > maxi)
maxi = k;
}
}
child[head] += maxi;
return child[head];
}
int main() {
for (int i = 0; i <= 100001; i++) {
child[i] = 0;
marker[i] = 0;
}
int n, m;
cin >> n;
cin >> m;
vector<int> v[n + 1];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a;
cin >> b;
v[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
if (marker[i] == 0) {
marker[i] = 1;
int y = dfs(i, v);
if (y > maximumm)
maximumm = y;
}
}
cout << maximumm - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int child[100001];
int marker[100001];
int maximumm = 0;
int dfs(int head, vector<int> v[]) {
child[head] = 1;
int maxi = 0;
for (int i = 0; i < v[head].size(); i++) {
// maxi=0;
if (marker[v[head][i]] == 0) {
marker[v[head][i]] = 1;
int x = dfs(v[head][i], v);
if (x > maxi)
maxi = x;
} else {
int k = child[v[head][i]];
if (k > maxi)
maxi = k;
}
}
child[head] += maxi;
return child[head];
}
int main() {
for (int i = 0; i <= 100001; i++) {
child[i] = 0;
marker[i] = 0;
}
int n, m;
cin >> n;
cin >> m;
vector<int> v[n + 1];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a;
cin >> b;
v[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
if (marker[i] == 0) {
marker[i] = 1;
int y = dfs(i, v);
if (y > maximumm)
maximumm = y;
}
}
cout << maximumm - 1 << endl;
return 0;
}
|
insert
| 11 | 11 | 11 | 12 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
/*author:anshumanc007
created on:08/01/2019
*/
// EMBRACE THE STRUGGLE!!!
#include <bits/stdc++.h>
#include <queue>
#include <stack>
using namespace std;
// typedef pair<long long int,long long int> pa;
#define MAX 100005
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
stack<long long int> st;
bool visited[MAX];
long long int dp[MAX];
void dfs(vector<long long int> adj[], long long int i) {
visited[i] = true;
long long int j;
for (auto j : adj[i]) {
dfs(adj, j);
}
st.push(i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l, m, n, o, p, q, r, x, y, a, b, mini = INF, maxi = 0,
cnt = 0, W, ans;
cin >> n >> m;
vector<long long int> adj[n];
vector<long long int> adj1[n];
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj1[y].push_back(x);
}
for (i = 0; i < n; i++) {
visited[i] = false;
dp[i] = 0;
}
for (i = 0; i < n; i++) {
if (!visited[i]) {
dfs(adj, i);
}
}
vector<long long int> V;
while (!st.empty()) {
j = st.top();
st.pop();
V.push_back(j);
}
for (j = V.size() - 1; j >= 0; j--) {
i = V[j];
// st.pop();
for (auto k : adj1[i]) {
dp[k] = max(dp[k], dp[i] + 1);
if (dp[k] > maxi) {
maxi = dp[k];
}
}
}
cout << maxi;
}
|
/*author:anshumanc007
created on:08/01/2019
*/
// EMBRACE THE STRUGGLE!!!
#include <bits/stdc++.h>
#include <queue>
#include <stack>
using namespace std;
// typedef pair<long long int,long long int> pa;
#define MAX 100005
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
stack<long long int> st;
bool visited[MAX];
long long int dp[MAX];
void dfs(vector<long long int> adj[], long long int i) {
visited[i] = true;
long long int j;
for (auto j : adj[i]) {
if (!visited[j])
dfs(adj, j);
}
st.push(i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l, m, n, o, p, q, r, x, y, a, b, mini = INF, maxi = 0,
cnt = 0, W, ans;
cin >> n >> m;
vector<long long int> adj[n];
vector<long long int> adj1[n];
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj1[y].push_back(x);
}
for (i = 0; i < n; i++) {
visited[i] = false;
dp[i] = 0;
}
for (i = 0; i < n; i++) {
if (!visited[i]) {
dfs(adj, i);
}
}
vector<long long int> V;
while (!st.empty()) {
j = st.top();
st.pop();
V.push_back(j);
}
for (j = V.size() - 1; j >= 0; j--) {
i = V[j];
// st.pop();
for (auto k : adj1[i]) {
dp[k] = max(dp[k], dp[i] + 1);
if (dp[k] > maxi) {
maxi = dp[k];
}
}
}
cout << maxi;
}
|
replace
| 20 | 21 | 20 | 22 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ff first
#define ss second
#define endl "\n"
#define all(x) (x).begin(), (x).end()
#define PI 3.1415926535897932384626433832795
int MOD = 1e9 + 7;
int powmod(int a, int l, int md) {
int res = 1;
while (l) {
if (l & 1)
res = res * a % md;
l /= 2;
a = a * a % md;
}
return res;
}
typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll, ll> ii;
typedef vector<ii> vii;
#define pb push_back
int __set(int b, int i) { return b | (1 << i); } // set ith bit
int __unset(int b, int i) { return b & !(1 << i); }
int __check(int b, int i) { return b & (1 << i); } // returns 0 if ith bit is 0
int mul(int a, int b) { return ((a % MOD) * (b % MOD)) % MOD; }
int add(int a, int b) { return (a + b) % MOD; }
int sub(int a, int b) { return (((a - b) % MOD) + MOD) % MOD; }
int __div(int a, int b) {
return mul(a, powmod(b, MOD - 2, MOD));
} // if MOD is prime;
const int inf = 0xFFFFFFFFFFFFFFFL; // very large number
priority_queue<int, vector<int>, greater<int>> pq; // for min priority_queue
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
clock_t time_p = clock();
void time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
int n, m;
vi vis(100010, 0);
int dp[100010];
int dfs(int v, vector<vi> adjlist) {
vis[v] = 1;
// if(!adjlist[v].size())
// return 0;
int mx = 0;
for (int i = 0; i < adjlist[v].size(); i++) {
int u = adjlist[v][i];
// cout<<u<<" fefe "<<v<<" "<<vis[u]<<" "<<vis[v]<<endl;
if (vis[u]) {
// cout<<"fe "<<dp[u]<<endl;
mx = max(mx, dp[u] + 1);
} else
mx = max(mx, dfs(u, adjlist) + 1);
}
dp[v] = mx;
// cout<<mx<<" "<<v<<endl;
return dp[v];
}
int32_t main(void) {
IOS;
cin >> n >> m;
vector<vi> adjlist(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adjlist[u - 1].pb(v - 1);
}
for (int i = 0; i < n; i++)
dp[i] = -1;
for (int i = 0; i < n; i++) {
if (!adjlist[i].size()) {
dp[i] = 0;
vis[i] = 1;
}
}
// cout<<dp[3]<<endl;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dp[i] = dfs(i, adjlist);
}
}
cout << *max_element(dp, dp + n) << endl;
time();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ff first
#define ss second
#define endl "\n"
#define all(x) (x).begin(), (x).end()
#define PI 3.1415926535897932384626433832795
int MOD = 1e9 + 7;
int powmod(int a, int l, int md) {
int res = 1;
while (l) {
if (l & 1)
res = res * a % md;
l /= 2;
a = a * a % md;
}
return res;
}
typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll, ll> ii;
typedef vector<ii> vii;
#define pb push_back
int __set(int b, int i) { return b | (1 << i); } // set ith bit
int __unset(int b, int i) { return b & !(1 << i); }
int __check(int b, int i) { return b & (1 << i); } // returns 0 if ith bit is 0
int mul(int a, int b) { return ((a % MOD) * (b % MOD)) % MOD; }
int add(int a, int b) { return (a + b) % MOD; }
int sub(int a, int b) { return (((a - b) % MOD) + MOD) % MOD; }
int __div(int a, int b) {
return mul(a, powmod(b, MOD - 2, MOD));
} // if MOD is prime;
const int inf = 0xFFFFFFFFFFFFFFFL; // very large number
priority_queue<int, vector<int>, greater<int>> pq; // for min priority_queue
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
clock_t time_p = clock();
void time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
int n, m;
vi vis(100010, 0);
int dp[100010];
int dfs(int v, vector<vi> &adjlist) {
vis[v] = 1;
// if(!adjlist[v].size())
// return 0;
int mx = 0;
for (int i = 0; i < adjlist[v].size(); i++) {
int u = adjlist[v][i];
// cout<<u<<" fefe "<<v<<" "<<vis[u]<<" "<<vis[v]<<endl;
if (vis[u]) {
// cout<<"fe "<<dp[u]<<endl;
mx = max(mx, dp[u] + 1);
} else
mx = max(mx, dfs(u, adjlist) + 1);
}
dp[v] = mx;
// cout<<mx<<" "<<v<<endl;
return dp[v];
}
int32_t main(void) {
IOS;
cin >> n >> m;
vector<vi> adjlist(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adjlist[u - 1].pb(v - 1);
}
for (int i = 0; i < n; i++)
dp[i] = -1;
for (int i = 0; i < n; i++) {
if (!adjlist[i].size()) {
dp[i] = 0;
vis[i] = 1;
}
}
// cout<<dp[3]<<endl;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dp[i] = dfs(i, adjlist);
}
}
cout << *max_element(dp, dp + n) << endl;
time();
return 0;
}
|
replace
| 47 | 48 | 47 | 48 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int INF = 1e9 + 5;
int dp[N];
bool vis[N];
vector<int> adj[N];
int mx = 0;
int calc(int x) {
if (x < 1)
return -1 * INF;
if (vis[x])
return dp[x];
vis[x] = 1;
int mx_dist = 0;
if (adj[x].size())
for (auto i : adj[x]) {
mx_dist = max(mx_dist, calc(i) + 1);
}
return dp[x] = max(dp[x], mx_dist);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
if (!vis[i])
calc(i);
mx = max(mx, dp[i]);
}
cout << mx << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 1e9 + 5;
int dp[N];
bool vis[N];
vector<int> adj[N];
int mx = 0;
int calc(int x) {
if (x < 1)
return -1 * INF;
if (vis[x])
return dp[x];
vis[x] = 1;
int mx_dist = 0;
if (adj[x].size())
for (auto i : adj[x]) {
mx_dist = max(mx_dist, calc(i) + 1);
}
return dp[x] = max(dp[x], mx_dist);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
if (!vis[i])
calc(i);
mx = max(mx, dp[i]);
}
cout << mx << '\n';
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int dfs(vector<int> g[], int dp[], int x) {
int temp = 0;
for (auto it : g[x]) {
temp = max(temp, dfs(g, dp, it) + 1);
}
dp[x] = temp;
return temp;
}
int longest_path(vector<int> g[], int n) {
int dp[n];
for (int i = 0; i < n; i++) {
dp[i] = -1;
}
for (int i = 0; i < n; i++) {
if (dp[i] == -1) {
dfs(g, dp, i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, dp[i]);
}
return ans;
}
void input() {
int n, m;
cin >> n >> m;
vector<int> g[n];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x -= 1;
y -= 1;
g[x].push_back(y);
}
int ans = longest_path(g, n);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int dfs(vector<int> g[], int dp[], int x) {
if (dp[x] != -1) {
return dp[x];
}
int temp = 0;
for (auto it : g[x]) {
temp = max(temp, dfs(g, dp, it) + 1);
}
dp[x] = temp;
return temp;
}
int longest_path(vector<int> g[], int n) {
int dp[n];
for (int i = 0; i < n; i++) {
dp[i] = -1;
}
for (int i = 0; i < n; i++) {
if (dp[i] == -1) {
dfs(g, dp, i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, dp[i]);
}
return ans;
}
void input() {
int n, m;
cin >> n >> m;
vector<int> g[n];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x -= 1;
y -= 1;
g[x].push_back(y);
}
int ans = longest_path(g, n);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
return 0;
}
|
insert
| 7 | 7 | 7 | 12 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define MOD 1000000007
#define LINF (long long)4e18
using ll = long long;
vector<vector<int>> G;
int N, M;
int dp[100010];
int rec(int v) {
if (dp[v] != -1)
return dp[v];
int res = 0;
for (auto next : G[v]) {
res = max(res, rec(next) + 1);
}
return dp[v] = res;
}
int main() {
cin >> N >> M;
G = vector<vector<int>>(M);
rep(i, N) { dp[i] = -1; }
rep(i, M) {
int x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
}
int res = 0;
rep(i, N) { res = max(res, rec(i)); }
cout << res << endl;
}
|
#include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define MOD 1000000007
#define LINF (long long)4e18
using ll = long long;
vector<vector<int>> G;
int N, M;
int dp[100010];
int rec(int v) {
if (dp[v] != -1)
return dp[v];
int res = 0;
for (auto next : G[v]) {
res = max(res, rec(next) + 1);
}
return dp[v] = res;
}
int main() {
cin >> N >> M;
G.resize(N);
rep(i, N) { dp[i] = -1; }
rep(i, M) {
int x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
}
int res = 0;
rep(i, N) { res = max(res, rec(i)); }
cout << res << endl;
}
|
replace
| 36 | 37 | 36 | 37 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
// **** WHEN THE GOING GETS TOUGH, THE TOUGH GETS GOING. ****
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
// added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector<int> vi;
typedef vector<ll> lvi;
typedef vector<vi> vvi;
typedef vector<lvi> lvvi;
typedef pair<int, int> ii;
typedef pair<ll, ll> lii;
typedef vector<ii> vii;
typedef vector<lii> lvii;
#define min_prq(t) priority_queue<t, vector<t>, greater<t>>
#define max_prq(t) priority_queue<t>
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define tr(c, i) \
for (auto i = (c).begin(); i != (c).end(); i++) // remember i is an iterator
#define present(c, x) ((c).find(x) != (c).end()) // for sets,maps,multimaps
#define cpresent(c, x) (find(all(c), x) != (c).end()) // for vectors
#define tc(t) \
int(t); \
cin >> (t); \
while ((t)--)
#define ff first
#define ss second
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " is " << a << endl;
err(++it, args...);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
#define mod 1000000007
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
ll mod_sum() { return 0LL; }
template <typename T, typename... Args> T mod_sum(T a, Args... args) {
return ((a + mod_sum(args...)) % mod + mod) % mod;
}
ll mod_product() { return 1LL; }
template <typename T, typename... Args> T mod_product(T a, Args... args) {
return (a * mod_product(args...)) % mod;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
ll ans = 0;
lvi dp;
vector<bool> visited;
lvvi adj;
ll dfs(ll x) {
if (visited[x])
return dp[x];
dp[x] = 0;
for (auto next : adj[x]) {
dp[x] = max(dp[x], 1 + dfs(next));
}
ans = max(ans, dp[x]);
return dp[x];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
adj.resize(n + 2);
dp.resize(n + 2);
visited.resize(n + 2);
for (int i = 0; i < m; ++i) {
ll x, y;
cin >> x >> y;
adj[x].pb(y);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
}
}
cout << ans << endl;
return 0;
}
|
// **** WHEN THE GOING GETS TOUGH, THE TOUGH GETS GOING. ****
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
// added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector<int> vi;
typedef vector<ll> lvi;
typedef vector<vi> vvi;
typedef vector<lvi> lvvi;
typedef pair<int, int> ii;
typedef pair<ll, ll> lii;
typedef vector<ii> vii;
typedef vector<lii> lvii;
#define min_prq(t) priority_queue<t, vector<t>, greater<t>>
#define max_prq(t) priority_queue<t>
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define tr(c, i) \
for (auto i = (c).begin(); i != (c).end(); i++) // remember i is an iterator
#define present(c, x) ((c).find(x) != (c).end()) // for sets,maps,multimaps
#define cpresent(c, x) (find(all(c), x) != (c).end()) // for vectors
#define tc(t) \
int(t); \
cin >> (t); \
while ((t)--)
#define ff first
#define ss second
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " is " << a << endl;
err(++it, args...);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
#define mod 1000000007
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
ll mod_sum() { return 0LL; }
template <typename T, typename... Args> T mod_sum(T a, Args... args) {
return ((a + mod_sum(args...)) % mod + mod) % mod;
}
ll mod_product() { return 1LL; }
template <typename T, typename... Args> T mod_product(T a, Args... args) {
return (a * mod_product(args...)) % mod;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
ll ans = 0;
lvi dp;
vector<bool> visited;
lvvi adj;
ll dfs(ll x) {
if (visited[x])
return dp[x];
visited[x] = true;
dp[x] = 0;
for (auto next : adj[x]) {
dp[x] = max(dp[x], 1 + dfs(next));
}
ans = max(ans, dp[x]);
return dp[x];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
adj.resize(n + 2);
dp.resize(n + 2);
visited.resize(n + 2);
for (int i = 0; i < m; ++i) {
ll x, y;
cin >> x >> y;
adj[x].pb(y);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
}
}
cout << ans << endl;
return 0;
}
|
insert
| 77 | 77 | 77 | 78 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
ll n, m;
vector<vector<ll>> G(n);
ll dp[100100];
ll rec(ll v) {
if (dp[v] != -1)
return dp[v];
ll res = 0;
for (auto nv : G[v]) {
chmax(res, rec(nv) + 1);
}
return dp[v] = res;
}
int main() {
cin >> n >> m;
rep(i, m) {
ll x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
}
rep(v, n) dp[v] = -1;
ll res = 0;
rep(v, n) chmax(res, rec(v));
cout << res << endl;
}
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
ll n, m;
vector<vector<ll>> G(100100);
ll dp[100100];
ll rec(ll v) {
if (dp[v] != -1)
return dp[v];
ll res = 0;
for (auto nv : G[v]) {
chmax(res, rec(nv) + 1);
}
return dp[v] = res;
}
int main() {
cin >> n >> m;
rep(i, m) {
ll x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
}
rep(v, n) dp[v] = -1;
ll res = 0;
rep(v, n) chmax(res, rec(v));
cout << res << endl;
}
|
replace
| 23 | 24 | 23 | 24 |
-11
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (ll i = 0; i < (n); i++)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x << ": " << x << endl;
#else
#define debug(x)
#endif
vvll g;
ll dp[110000];
bool check[110000];
void dfs(ll x) {
if (check[x])
return;
ll tmp = 0;
for (auto nx : g[x]) {
dfs(nx);
chmax(tmp, dp[nx] + 1);
}
dp[x] = tmp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll N, M;
cin >> N >> M;
g.resize(N);
rep(_, M) {
ll x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
}
rep(i, N) dfs(i);
ll ans = 0;
rep(i, N) chmax(ans, dp[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (ll i = 0; i < (n); i++)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x << ": " << x << endl;
#else
#define debug(x)
#endif
vvll g;
ll dp[110000];
bool check[110000];
void dfs(ll x) {
if (check[x])
return;
ll tmp = 0;
for (auto nx : g[x]) {
dfs(nx);
chmax(tmp, dp[nx] + 1);
}
check[x] = true;
dp[x] = tmp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll N, M;
cin >> N >> M;
g.resize(N);
rep(_, M) {
ll x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
}
rep(i, N) dfs(i);
ll ans = 0;
rep(i, N) chmax(ans, dp[i]);
cout << ans << endl;
}
|
insert
| 39 | 39 | 39 | 40 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define mod 1000000007
#define check exit(0)
#define nl cout << endl;
#define inp 10
#define ordered_set \
tree<int, null_type, less_equal<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define ll long long int
#define trace(x) cerr << #x << " : " << x << endl;
#define deb(v) \
for (int i = 0; i < v.size(); i++) { \
cout << v[i]; \
(i == v.size() - 1) ? cout << "\n" : cout << " "; \
}
#define jaldi \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace __gnu_pbds;
using namespace std;
// Pick yourself up, 'cause...
vector<int> g[100005];
vector<bool> visited(100005, false);
vector<int> start(inp, 0);
void dfs(int n) {
if (visited[n])
return;
visited[n] = true;
for (int c : g[n]) {
dfs(c);
start[n] = max(start[n], 1 + start[c]);
}
}
int main() {
jaldi
int n,
m;
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!visited[i])
dfs(i);
}
for (int i = 1; i <= n; i++)
visited[i] = false;
// deb(start);
// for(int i=1;i<=n;i++)
// {
// if(!visited[i]) dfs(i);
// }
// deb(start);
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(ans, start[i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define mod 1000000007
#define check exit(0)
#define nl cout << endl;
#define inp 200005
#define ordered_set \
tree<int, null_type, less_equal<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define ll long long int
#define trace(x) cerr << #x << " : " << x << endl;
#define deb(v) \
for (int i = 0; i < v.size(); i++) { \
cout << v[i]; \
(i == v.size() - 1) ? cout << "\n" : cout << " "; \
}
#define jaldi \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace __gnu_pbds;
using namespace std;
// Pick yourself up, 'cause...
vector<int> g[100005];
vector<bool> visited(100005, false);
vector<int> start(inp, 0);
void dfs(int n) {
if (visited[n])
return;
visited[n] = true;
for (int c : g[n]) {
dfs(c);
start[n] = max(start[n], 1 + start[c]);
}
}
int main() {
jaldi
int n,
m;
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!visited[i])
dfs(i);
}
for (int i = 1; i <= n; i++)
visited[i] = false;
// deb(start);
// for(int i=1;i<=n;i++)
// {
// if(!visited[i]) dfs(i);
// }
// deb(start);
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(ans, start[i]);
cout << ans;
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
vector<int> a[100005];
int dp[100005], n, m;
int dfs(int i) {
if (dp[i] != -1)
return dp[i];
int ans = 0;
for (int x : a[i])
ans = max(ans, dfs(x) + 1);
return ans;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
}
int ans = 0, i;
for (i = 1; i <= n; i++)
ans = max(ans, dfs(i));
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
vector<int> a[100005];
int dp[100005], n, m;
int dfs(int i) {
if (dp[i] != -1)
return dp[i];
int ans = 0;
for (int x : a[i])
ans = max(ans, dfs(x) + 1);
return dp[i] = ans;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
}
int ans = 0, i;
for (i = 1; i <= n; i++)
ans = max(ans, dfs(i));
cout << ans << endl;
}
|
replace
| 11 | 12 | 11 | 12 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
constexpr size_t MAXN = 1e5;
constexpr size_t MAXM = 1e5;
constexpr int MOD = 1e9 + 7;
std::vector<std::vector<int>> graph;
std::vector<int> dp;
std::vector<bool> traversed;
void traverse(int to) {
for (int from : graph[to]) {
if (!traversed[from]) {
traverse(from);
}
dp[to] = std::max(dp[to], dp[from] + 1);
}
}
void solve() {
int N, M;
std::cin >> N >> M;
graph.resize(N + 1);
dp.resize(N + 1);
traversed.resize(N + 1);
for (int i = 0; i < M; ++i) {
int from, to;
std::cin >> from >> to;
graph[to].push_back(from);
}
for (int to = 1; to <= N; to++) {
if (!graph[to].empty()) {
traverse(to);
}
}
int mx = dp[0];
for (int to : dp) {
mx = std::max(to, mx);
}
std::cout << mx << "\n";
}
void warp() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
}
int main() {
warp();
solve();
return 0;
}
|
#include <iostream>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
constexpr size_t MAXN = 1e5;
constexpr size_t MAXM = 1e5;
constexpr int MOD = 1e9 + 7;
std::vector<std::vector<int>> graph;
std::vector<int> dp;
std::vector<bool> traversed;
void traverse(int to) {
for (int from : graph[to]) {
if (!traversed[from]) {
traverse(from);
traversed[from] = true;
}
dp[to] = std::max(dp[to], dp[from] + 1);
}
}
void solve() {
int N, M;
std::cin >> N >> M;
graph.resize(N + 1);
dp.resize(N + 1);
traversed.resize(N + 1);
for (int i = 0; i < M; ++i) {
int from, to;
std::cin >> from >> to;
graph[to].push_back(from);
}
for (int to = 1; to <= N; to++) {
if (!graph[to].empty()) {
traverse(to);
}
}
int mx = dp[0];
for (int to : dp) {
mx = std::max(to, mx);
}
std::cout << mx << "\n";
}
void warp() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
}
int main() {
warp();
solve();
return 0;
}
|
insert
| 18 | 18 | 18 | 19 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) {
is >> x;
}
return is;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (T i : a) {
out << i << ',';
}
out << ']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const int MOD = 1000000007;
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<vector<ll>> g(n);
REP(i, m) {
ll x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
}
vector<ll> dp(n, -1);
function<ll(ll)> dfs = [&](ll v) {
// cout << v << endl;
if (dp[v] != -1)
return dp[v];
ll ret = 0;
for (auto to : g[v]) {
chmax(ret, dfs(to) + 1);
}
return ret;
};
ll ans = 0;
REP(i, n) chmax(ans, dfs(i));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) {
is >> x;
}
return is;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (T i : a) {
out << i << ',';
}
out << ']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const int MOD = 1000000007;
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<vector<ll>> g(n);
REP(i, m) {
ll x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
}
vector<ll> dp(n, -1);
function<ll(ll)> dfs = [&](ll v) {
// cout << v << endl;
if (dp[v] != -1)
return dp[v];
ll ret = 0;
for (auto to : g[v]) {
chmax(ret, dfs(to) + 1);
}
return dp[v] = ret;
};
ll ans = 0;
REP(i, n) chmax(ans, dfs(i));
cout << ans << endl;
return 0;
}
|
replace
| 78 | 79 | 78 | 79 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define REVETSE(c) reverse((c).begin(), (c).end())
#define SUM(c) accumulate((c).begin(), (c).end(), 0)
#define ALL(a) (a).begin(), (a).end()
// int gcd(int a,int b){return b?gcd(b,a%b):a;}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> T maxt(T x, T y) {
if (x > y)
return x;
else
return y;
}
template <class T> T mint(T x, T y) {
if (x > y)
return y;
else
return x;
}
// sort(v.rbegin(), v.rend(), [](auto& x, auto& y){return x[1] < y[1];});
// cout << fixed << setprecision(10) << ans << defaultfloat << endl;
typedef long long ll;
typedef vector<int> Vi;
typedef vector<ll> Vl;
typedef vector<double> Vd;
typedef vector<string> Vs;
// 小数出力
double print_double(double d) { printf("%.8f", d); }
long long m = 1e9 + 7, mod = 1e9 + 7;
// 逆元 a/b の modをとるとき -> a*modinv(b)%mod
long long modinv(long long a, long long m = 1e9 + 7) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// 約数列挙
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
int main() {
int N, M, x, y;
cin >> N >> M;
Vi in(N, 0);
vector<Vi> v(N);
rep(i, M) {
cin >> x >> y;
v[x - 1].push_back(y - 1);
in[y - 1]++;
}
// rep(i,N){
// cout << in[i] << ' ' << endl;
// }
Vi memo(N, 0);
queue<int> q;
rep(inix, N) {
if (in[inix] > 0)
continue;
q.push(inix);
}
while (!q.empty()) {
int ch = q.front();
q.pop();
// cout << "ch=" << ch << endl;
for (auto i : v[ch]) {
q.push(i);
memo[i] = memo[ch] + 1;
}
}
cout << *max_element(ALL(memo));
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define REVETSE(c) reverse((c).begin(), (c).end())
#define SUM(c) accumulate((c).begin(), (c).end(), 0)
#define ALL(a) (a).begin(), (a).end()
// int gcd(int a,int b){return b?gcd(b,a%b):a;}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> T maxt(T x, T y) {
if (x > y)
return x;
else
return y;
}
template <class T> T mint(T x, T y) {
if (x > y)
return y;
else
return x;
}
// sort(v.rbegin(), v.rend(), [](auto& x, auto& y){return x[1] < y[1];});
// cout << fixed << setprecision(10) << ans << defaultfloat << endl;
typedef long long ll;
typedef vector<int> Vi;
typedef vector<ll> Vl;
typedef vector<double> Vd;
typedef vector<string> Vs;
// 小数出力
double print_double(double d) { printf("%.8f", d); }
long long m = 1e9 + 7, mod = 1e9 + 7;
// 逆元 a/b の modをとるとき -> a*modinv(b)%mod
long long modinv(long long a, long long m = 1e9 + 7) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// 約数列挙
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
int main() {
int N, M, x, y;
cin >> N >> M;
Vi in(N, 0);
vector<Vi> v(N);
rep(i, M) {
cin >> x >> y;
v[x - 1].push_back(y - 1);
in[y - 1]++;
}
// rep(i,N){
// cout << in[i] << ' ' << endl;
// }
Vi memo(N, 0);
queue<int> q;
rep(inix, N) {
if (in[inix] > 0)
continue;
q.push(inix);
}
while (!q.empty()) {
int ch = q.front();
q.pop();
// cout << "ch=" << ch << endl;
for (auto i : v[ch]) {
in[i]--;
if (in[i] == 0) {
q.push(i);
memo[i] = memo[ch] + 1;
}
}
}
cout << *max_element(ALL(memo));
}
|
replace
| 103 | 105 | 103 | 108 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
#define vec(s) vector<s>;
#define vvec(s) vector<vector<s>>;
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli, lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define YN(x) cout << (bool x ? "Yes" : "No") << endl;
#define out(s) cout << s << endl;
#define pb(s) push_back(s);
#define sp " ";
#define INF 10000000000
#define all(s) s.begin(), s.end()
void vout(vi v) {
for (int i = 0; i < v.size(); i++)
cout << v.at(i) << endl;
}
lli f(lli x, vvi edge, vi &dp) {
if (dp[x] != -1) {
return dp[x];
}
lli res = 0;
if (edge[x].size() == 0)
return dp[x] = res;
rep(i, edge[x].size()) { res = max(res, f(edge[x][i], edge, dp)); }
dp[x] = res + 1;
return dp[x];
}
int main() {
lli n, m, ans = 0;
cin >> n >> m;
vvi edge(n);
vi dp(n, -1);
vector<bool> s(n, true);
rep(i, m) {
lli x, y;
cin >> x >> y;
x--;
y--;
edge[x].push_back(y);
s[y] = false;
}
rep(i, n) {
if (!s[i])
continue;
else {
ans = max(ans, f(i, edge, dp));
}
}
out(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
#define vec(s) vector<s>;
#define vvec(s) vector<vector<s>>;
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli, lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define YN(x) cout << (bool x ? "Yes" : "No") << endl;
#define out(s) cout << s << endl;
#define pb(s) push_back(s);
#define sp " ";
#define INF 10000000000
#define all(s) s.begin(), s.end()
void vout(vi v) {
for (int i = 0; i < v.size(); i++)
cout << v.at(i) << endl;
}
lli f(lli x, vvi &edge, vi &dp) {
if (dp[x] != -1) {
return dp[x];
}
lli res = 0;
if (edge[x].size() == 0)
return dp[x] = res;
rep(i, edge[x].size()) { res = max(res, f(edge[x][i], edge, dp)); }
dp[x] = res + 1;
return dp[x];
}
int main() {
lli n, m, ans = 0;
cin >> n >> m;
vvi edge(n);
vi dp(n, -1);
vector<bool> s(n, true);
rep(i, m) {
lli x, y;
cin >> x >> y;
x--;
y--;
edge[x].push_back(y);
s[y] = false;
}
rep(i, n) {
if (!s[i])
continue;
else {
ans = max(ans, f(i, edge, dp));
}
}
out(ans);
}
|
replace
| 21 | 22 | 21 | 22 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 1e9 + 7;
vector<vector<int>> G(1000010);
int dp[100010];
int dfs(int n) {
if (G[n].size()) {
int ma = 0;
for (auto e : G[n]) {
ma = max(ma, dfs(e));
}
return dp[n] = ma + 1;
} else {
return dp[n] = 0;
}
}
int main() {
int n, m;
cin >> n >> m;
REP(i, 1, n + 1) dp[i] = -1;
rep(i, m) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
}
REP(i, 1, n + 1) {
if (dp[i] >= 0)
continue;
dfs(i);
}
int k = 0;
REP(i, 1, n + 1) { k = max(k, dp[i]); }
cout << k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 1e9 + 7;
vector<vector<int>> G(1000010);
int dp[100010];
int dfs(int n) {
if (G[n].size()) {
int ma = 0;
for (auto e : G[n]) {
if (dp[e] >= 0)
ma = max(ma, dp[e]);
else
ma = max(ma, dfs(e));
}
return dp[n] = ma + 1;
} else {
return dp[n] = 0;
}
}
int main() {
int n, m;
cin >> n >> m;
REP(i, 1, n + 1) dp[i] = -1;
rep(i, m) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
}
REP(i, 1, n + 1) {
if (dp[i] >= 0)
continue;
dfs(i);
}
int k = 0;
REP(i, 1, n + 1) { k = max(k, dp[i]); }
cout << k << endl;
}
|
replace
| 14 | 15 | 14 | 18 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int dfs(int node, vector<vector<int>> &adj, vector<bool> &vis,
vector<int> &dist) {
if (!vis[node]) {
for (auto &x : adj[node]) {
dist[node] = max(dist[node], dfs(x, adj, vis, dist) + 1);
}
}
return dist[node];
}
int main() {
int N, M;
cin >> N >> M;
vector<int> dist(N + 1);
vector<bool> vis(N + 1);
vector<vector<int>> adj(N + 1);
int sta, sto;
for (int i = 0; i < M; i++) {
cin >> sta >> sto;
adj[sta].push_back(sto);
}
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
dfs(i, adj, vis, dist);
}
}
int ans = 0;
for (auto &x : dist) {
ans = max(ans, x);
}
cout << ans;
}
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int dfs(int node, vector<vector<int>> &adj, vector<bool> &vis,
vector<int> &dist) {
if (!vis[node]) {
vis[node] = 1;
for (auto &x : adj[node]) {
dist[node] = max(dist[node], dfs(x, adj, vis, dist) + 1);
}
}
return dist[node];
}
int main() {
int N, M;
cin >> N >> M;
vector<int> dist(N + 1);
vector<bool> vis(N + 1);
vector<vector<int>> adj(N + 1);
int sta, sto;
for (int i = 0; i < M; i++) {
cin >> sta >> sto;
adj[sta].push_back(sto);
}
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
dfs(i, adj, vis, dist);
}
}
int ans = 0;
for (auto &x : dist) {
ans = max(ans, x);
}
cout << ans;
}
|
insert
| 7 | 7 | 7 | 8 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int dp[n + 1];
for (int i = 0; i <= n; i++) {
dp[i] = 0;
}
vector<int> v[n + 1];
int indegree[n + 1];
for (int i = 0; i <= n; i++) {
indegree[i] = 0;
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
indegree[y]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (indegree[i] == 0) {
q.push(i);
dp[i] = 0;
}
}
while (!q.empty()) {
int k = q.size();
while (k--) {
int curr = q.front();
q.pop();
for (int i = 0; i < v[curr].size(); i++) {
q.push(v[curr][i]);
dp[v[curr][i]] = max(dp[v[curr][i]], dp[curr] + 1);
}
}
}
int ans = INT_MIN;
for (int i = 0; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int dp[n + 1];
for (int i = 0; i <= n; i++) {
dp[i] = 0;
}
vector<int> v[n + 1];
int indegree[n + 1];
for (int i = 0; i <= n; i++) {
indegree[i] = 0;
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
indegree[y]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (indegree[i] == 0) {
q.push(i);
dp[i] = 0;
}
}
while (!q.empty()) {
int k = q.size();
while (k--) {
int curr = q.front();
q.pop();
int s = v[curr].size();
for (int i = 0; i < s; i++) {
indegree[v[curr][i]]--;
if (indegree[v[curr][i]] == 0) {
q.push(v[curr][i]);
dp[v[curr][i]] = max(dp[v[curr][i]], dp[curr] + 1);
}
}
}
}
int ans = INT_MIN;
for (int i = 0; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
}
|
replace
| 39 | 43 | 39 | 46 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <cstdlib>
#include <iostream>
#include <vector>
void dfs(int i, std::vector<std::vector<int>> graph, std::vector<int> &in,
std::vector<long> &dp, std::vector<bool> &visited) {
visited[i] = true;
for (auto n : graph[i]) {
dp[n] = std::max(dp[n], dp[i] + 1);
--in[n];
if (in[n] == 0) {
dfs(n, graph, in, dp, visited);
}
}
}
int main() {
int N, M;
std::cin >> N >> M;
std::vector<std::vector<int>> graph(N, std::vector<int>{});
std::vector<int> in(N, 0);
for (int i = 0; i < M; ++i) {
int x, y;
std::cin >> x >> y;
graph[x - 1].push_back(y - 1);
++in[y - 1];
}
std::vector<bool> visited(N, false);
std::vector<long> dp(N, 0);
for (int i = 0; i < N; ++i) {
if (!visited[i] && in[i] == 0) {
dfs(i, graph, in, dp, visited);
}
}
long max = 0;
for (int i = 0; i < N; ++i) {
max = std::max(max, dp[i]);
}
std::cout << max << "\n";
}
|
#include <cstdlib>
#include <iostream>
#include <vector>
void dfs(int i, std::vector<std::vector<int>> &graph, std::vector<int> &in,
std::vector<long> &dp, std::vector<bool> &visited) {
visited[i] = true;
for (auto n : graph[i]) {
dp[n] = std::max(dp[n], dp[i] + 1);
--in[n];
if (in[n] == 0) {
dfs(n, graph, in, dp, visited);
}
}
}
int main() {
int N, M;
std::cin >> N >> M;
std::vector<std::vector<int>> graph(N, std::vector<int>{});
std::vector<int> in(N, 0);
for (int i = 0; i < M; ++i) {
int x, y;
std::cin >> x >> y;
graph[x - 1].push_back(y - 1);
++in[y - 1];
}
std::vector<bool> visited(N, false);
std::vector<long> dp(N, 0);
for (int i = 0; i < N; ++i) {
if (!visited[i] && in[i] == 0) {
dfs(i, graph, in, dp, visited);
}
}
long max = 0;
for (int i = 0; i < N; ++i) {
max = std::max(max, dp[i]);
}
std::cout << max << "\n";
}
|
replace
| 4 | 5 | 4 | 5 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
// KiSmAt
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int N = 2 * 1e5 + 10;
ll res;
ll a[N], vis[N];
vector<ll> v[N];
ll Dfs(ll node) {
for (auto i : v[node]) {
if (!vis[i])
Dfs(i);
a[node] = max(a[node], 1 + a[i]);
}
return a[node];
}
void solve() {
ll n, m, x, y;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
v[x].emplace_back(y);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
res = max(res, Dfs(i));
}
}
cout << res;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin >> t;
while (t--) {
solve();
}
}
// nEro
|
// KiSmAt
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int N = 2 * 1e5 + 10;
ll res;
ll a[N], vis[N];
vector<ll> v[N];
ll Dfs(ll node) {
vis[node] = 1;
for (auto i : v[node]) {
if (!vis[i])
Dfs(i);
a[node] = max(a[node], 1 + a[i]);
}
return a[node];
}
void solve() {
ll n, m, x, y;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
v[x].emplace_back(y);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
res = max(res, Dfs(i));
}
}
cout << res;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin >> t;
while (t--) {
solve();
}
}
// nEro
|
insert
| 15 | 15 | 15 | 16 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define Art Code
#define Artist Shivam Gupta
#define MoT This Art belongs to Artist
#define FASTIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define ll long long int
#define ld long double
#define vll vector<ll>
#define pll pair<ll, ll>
#define vl(p) vector<p>
#define W while
#define For(i, s, x) for (i = s; i < x; i++)
#define Fore(i, s, x) for (i = s; i <= x; i++)
#define FoR(i, s, x) for (i = s - 1; i >= x; i--)
#define ForE(i, s, x) for (i = s; i >= x; i--)
#define all(v) v.begin(), v.end()
#define pb push_back
#define in insert
#define sz size()
#define F first
#define S second
#define nl cout << "\n"
#define pr(a) cout << a << " "
#define pr2(a, b) cout << a << " " << b << "\n"
#define pr3(a, b, c) cout << a << " " << b << " " << c << "\n"
#define trace2(x, y) \
cout << #x << ": " << x << " | " << #y << ": " << y << endl;
#define trace3(x, y, z) \
cout << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl;
#define trace4(a, b, c, d) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl;
#define trace5(a, b, c, d, e) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl;
#define mod 1000000007
#define MAX 200005
vl(vll) out;
vll in, outs, ans;
void doit(ll n) {
for (auto r : out[n]) {
ans[r] = max(ans[r], ans[n] + 1);
doit(r);
}
}
int main() {
FASTIO;
ll t = 1, i, j, k, l;
// cin>>t;
W(t--) {
ll n, m;
cin >> n >> m;
out.resize(n + 1);
ans.resize(n + 1);
in.resize(n + 1);
For(i, 0, m) cin >> j >> k, out[j].pb(k), in[k]++;
Fore(i, 1, n) if (!in[i]) outs.pb(i);
for (auto r : outs)
doit(r);
pr(*max_element(all(ans)));
nl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define Art Code
#define Artist Shivam Gupta
#define MoT This Art belongs to Artist
#define FASTIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define ll long long int
#define ld long double
#define vll vector<ll>
#define pll pair<ll, ll>
#define vl(p) vector<p>
#define W while
#define For(i, s, x) for (i = s; i < x; i++)
#define Fore(i, s, x) for (i = s; i <= x; i++)
#define FoR(i, s, x) for (i = s - 1; i >= x; i--)
#define ForE(i, s, x) for (i = s; i >= x; i--)
#define all(v) v.begin(), v.end()
#define pb push_back
#define in insert
#define sz size()
#define F first
#define S second
#define nl cout << "\n"
#define pr(a) cout << a << " "
#define pr2(a, b) cout << a << " " << b << "\n"
#define pr3(a, b, c) cout << a << " " << b << " " << c << "\n"
#define trace2(x, y) \
cout << #x << ": " << x << " | " << #y << ": " << y << endl;
#define trace3(x, y, z) \
cout << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl;
#define trace4(a, b, c, d) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl;
#define trace5(a, b, c, d, e) \
cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl;
#define mod 1000000007
#define MAX 200005
vl(vll) out;
vll in, outs, ans;
void doit(ll n) {
for (auto r : out[n]) {
ans[r] = max(ans[r], ans[n] + 1);
in[r]--;
if (!in[r])
doit(r);
}
}
int main() {
FASTIO;
ll t = 1, i, j, k, l;
// cin>>t;
W(t--) {
ll n, m;
cin >> n >> m;
out.resize(n + 1);
ans.resize(n + 1);
in.resize(n + 1);
For(i, 0, m) cin >> j >> k, out[j].pb(k), in[k]++;
Fore(i, 1, n) if (!in[i]) outs.pb(i);
for (auto r : outs)
doit(r);
pr(*max_element(all(ans)));
nl;
}
return 0;
}
|
replace
| 50 | 51 | 50 | 53 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <queue>
#define qmin(x, y) (x = min(x, y))
#define qmax(x, y) (x = max(x, y))
using namespace std;
inline char gc() {
// static char buf[100000],*p1,*p2;
// return
//(p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
return getchar();
}
template <class T> int read(T &ans) {
ans = 0;
char ch = gc();
T f = 1;
while (!isdigit(ch)) {
if (ch == EOF)
return -1;
if (ch == '-')
f = -1;
ch = gc();
}
while (isdigit(ch))
ans = ans * 10 + ch - '0', ch = gc();
ans *= f;
return 1;
}
template <class T1, class T2> int read(T1 &a, T2 &b) {
return read(a) != EOF && read(b) != EOF ? 2 : EOF;
}
template <class T1, class T2, class T3> int read(T1 &a, T2 &b, T3 &c) {
return read(a, b) != EOF && read(c) != EOF ? 3 : EOF;
}
typedef long long ll;
const int Maxn = 3100;
const int inf = 0x3f3f3f3f;
int to[Maxn], nxt[Maxn], first[Maxn], tot = 1, d[Maxn], n, m, u, v, f[Maxn];
queue<int> q;
inline void add(int u, int v) {
to[tot] = v;
nxt[tot] = first[u];
first[u] = tot++;
}
signed main() {
// freopen("test.in","r",stdin);
read(n, m);
for (int i = 1; i <= m; i++) {
read(u, v);
add(u, v);
d[v]++;
}
for (int i = 1; i <= n; i++)
if (d[i] == 0)
q.push(i);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = first[now]; i; i = nxt[i]) {
qmax(f[to[i]], f[now] + 1);
d[to[i]]--;
if (d[to[i]] == 0)
q.push(to[i]);
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
qmax(ans, f[i]);
printf("%d\n", ans);
return 0;
}
|
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <queue>
#define qmin(x, y) (x = min(x, y))
#define qmax(x, y) (x = max(x, y))
using namespace std;
inline char gc() {
// static char buf[100000],*p1,*p2;
// return
//(p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
return getchar();
}
template <class T> int read(T &ans) {
ans = 0;
char ch = gc();
T f = 1;
while (!isdigit(ch)) {
if (ch == EOF)
return -1;
if (ch == '-')
f = -1;
ch = gc();
}
while (isdigit(ch))
ans = ans * 10 + ch - '0', ch = gc();
ans *= f;
return 1;
}
template <class T1, class T2> int read(T1 &a, T2 &b) {
return read(a) != EOF && read(b) != EOF ? 2 : EOF;
}
template <class T1, class T2, class T3> int read(T1 &a, T2 &b, T3 &c) {
return read(a, b) != EOF && read(c) != EOF ? 3 : EOF;
}
typedef long long ll;
const int Maxn = 110000;
const int inf = 0x3f3f3f3f;
int to[Maxn], nxt[Maxn], first[Maxn], tot = 1, d[Maxn], n, m, u, v, f[Maxn];
queue<int> q;
inline void add(int u, int v) {
to[tot] = v;
nxt[tot] = first[u];
first[u] = tot++;
}
signed main() {
// freopen("test.in","r",stdin);
read(n, m);
for (int i = 1; i <= m; i++) {
read(u, v);
add(u, v);
d[v]++;
}
for (int i = 1; i <= n; i++)
if (d[i] == 0)
q.push(i);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = first[now]; i; i = nxt[i]) {
qmax(f[to[i]], f[now] + 1);
d[to[i]]--;
if (d[to[i]] == 0)
q.push(to[i]);
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
qmax(ans, f[i]);
printf("%d\n", ans);
return 0;
}
|
replace
| 42 | 43 | 42 | 43 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
map<int, vector<int>> adj;
int n, m;
bool visited[10005];
int dp[10005];
void dfs(int n) {
visited[n] = true;
for (auto neigh : adj[n]) {
if (!visited[neigh])
dfs(neigh);
dp[n] = max(dp[n], 1 + dp[neigh]);
}
}
int solve(int n, int m, int *x, int *y) {
for (int i = 0; i < m; i++) {
adj[x[i]].push_back(y[i]);
}
for (int i = 1; i <= n; i++)
if (!visited[i])
dfs(i);
int r = 0;
for (int i = 1; i <= n; i++)
r = max(r, dp[i]);
return r;
}
int main() {
cin >> n >> m;
int x[m];
int y[m];
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
}
fill(visited, visited + n, false);
int r = solve(n, m, x, y);
cout << r << endl;
return 0;
}
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
map<int, vector<int>> adj;
int n, m;
bool visited[100005];
int dp[100005];
void dfs(int n) {
visited[n] = true;
for (auto neigh : adj[n]) {
if (!visited[neigh])
dfs(neigh);
dp[n] = max(dp[n], 1 + dp[neigh]);
}
}
int solve(int n, int m, int *x, int *y) {
for (int i = 0; i < m; i++) {
adj[x[i]].push_back(y[i]);
}
for (int i = 1; i <= n; i++)
if (!visited[i])
dfs(i);
int r = 0;
for (int i = 1; i <= n; i++)
r = max(r, dp[i]);
return r;
}
int main() {
cin >> n >> m;
int x[m];
int y[m];
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
}
fill(visited, visited + n, false);
int r = solve(n, m, x, y);
cout << r << endl;
return 0;
}
|
replace
| 7 | 9 | 7 | 9 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define pb push_back
#define ub upper_bound
#define lb lower_bound
#define vi vector<int>
#define sz(s) (int)s.size()
#define pii pair<int, int>
#define piii pair<int, pair<int, int>>
#define tiii tuple<int, int, int>
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
#define rall(v) v.rbegin(), v.rend()
#define endl '\n'
#define matrix vector<vector<int>>
#define boost \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define NAYAN \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define N 1006
#define mod 1000000007
#define mod2 998244353
#define inf 1e18
vector<int> g[N];
int ind[N];
int dist[N];
int vis[N];
void dfs(int u) {
vis[u] = 1;
for (int v : g[u]) {
ind[v]--;
dist[v] = max(dist[v], dist[u] + 1);
if (ind[v] == 0)
dfs(v);
}
}
int32_t main() {
boost
// #ifndef ONLINE_JUDGE
// NAYAN
// #endif
int n,
m;
cin >> n >> m;
int i;
int u, v;
for (i = 1; i <= m; i++) {
cin >> u >> v;
g[u].pb(v);
ind[v]++;
}
for (i = 1; i <= n; i++) {
if (ind[i] == 0 && vis[i] == 0) {
dfs(i);
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
ans = max(ans, dist[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define pb push_back
#define ub upper_bound
#define lb lower_bound
#define vi vector<int>
#define sz(s) (int)s.size()
#define pii pair<int, int>
#define piii pair<int, pair<int, int>>
#define tiii tuple<int, int, int>
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
#define rall(v) v.rbegin(), v.rend()
#define endl '\n'
#define matrix vector<vector<int>>
#define boost \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define NAYAN \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define N 100006
#define mod 1000000007
#define mod2 998244353
#define inf 1e18
vector<int> g[N];
int ind[N];
int dist[N];
int vis[N];
void dfs(int u) {
vis[u] = 1;
for (int v : g[u]) {
ind[v]--;
dist[v] = max(dist[v], dist[u] + 1);
if (ind[v] == 0)
dfs(v);
}
}
int32_t main() {
boost
// #ifndef ONLINE_JUDGE
// NAYAN
// #endif
int n,
m;
cin >> n >> m;
int i;
int u, v;
for (i = 1; i <= m; i++) {
cin >> u >> v;
g[u].pb(v);
ind[v]++;
}
for (i = 1; i <= n; i++) {
if (ind[i] == 0 && vis[i] == 0) {
dfs(i);
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
ans = max(ans, dist[i]);
}
cout << ans;
}
|
replace
| 25 | 26 | 25 | 26 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <string.h>
#define ll long long
#include <vector>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
const int mod = 1e9 + 7;
int n, m;
vector<int> adj[100005];
int dp[100005];
int longpath(int node) {
if (dp[node] != -1)
return dp[node];
int ans = 0;
for (auto i : adj[node]) {
ans = max(ans, 1 + longpath(node));
}
return dp[node] = ans;
}
int main() {
IOS;
cin >> n >> m;
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
}
for (int i = 1; i <= n; i++)
adj[0].push_back(i);
memset(dp, -1, sizeof(dp));
cout << longpath(0) - 1;
}
|
#include <bits/stdc++.h>
#include <string.h>
#define ll long long
#include <vector>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
const int mod = 1e9 + 7;
int n, m;
vector<int> adj[100005];
int dp[100005];
int longpath(int node) {
if (dp[node] != -1)
return dp[node];
int ans = 0;
for (auto i : adj[node]) {
ans = max(ans, 1 + longpath(i));
}
return dp[node] = ans;
}
int main() {
IOS;
cin >> n >> m;
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
}
for (int i = 1; i <= n; i++)
adj[0].push_back(i);
memset(dp, -1, sizeof(dp));
cout << longpath(0) - 1;
}
|
replace
| 18 | 19 | 18 | 19 |
-11
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define FaSt ios::sync_with_stdio(0), cin.tie(0);
#define random uniform_int_distribution<long long>(1, 2000000000000000LL)(rng)
const int N = 100005;
vector<vector<int>> g;
int n, m, dp[N], ans;
bool solved[N];
int dfs(int u) {
if (solved[u]) {
return dp[u];
}
for (auto v : g[u]) {
dp[u] = max(dp[u], 1 + dfs(v));
}
return dp[u];
}
int main() {
FaSt cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
}
for (int i = 0; i < n; i++) {
ans = max(ans, dfs(i));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FaSt ios::sync_with_stdio(0), cin.tie(0);
#define random uniform_int_distribution<long long>(1, 2000000000000000LL)(rng)
const int N = 100005;
vector<vector<int>> g;
int n, m, dp[N], ans;
bool solved[N];
int dfs(int u) {
if (solved[u]) {
return dp[u];
}
for (auto v : g[u]) {
dp[u] = max(dp[u], 1 + dfs(v));
}
solved[u] = 1;
return dp[u];
}
int main() {
FaSt cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
}
for (int i = 0; i < n; i++) {
ans = max(ans, dfs(i));
}
cout << ans;
}
|
insert
| 20 | 20 | 20 | 21 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
using namespace std;
#include <bits/stdc++.h>
#define pb push_back
#define mk make_pair
#define vect vector<ll>
#define maap map<ll, ll>
#define MOD 1000000007
#define mit map::iterator
#define pii pair<ll, ll>
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
typedef long long int ll;
// stringstream convert;
// convert << number;
// string s = convert.str();
ll fact[500005], invfact[500005];
ll power(ll x, ll y) {
ll z = 1;
while (y > 0) {
if (y % 2 == 1)
z = (z * x) % MOD;
x = (x * x) % MOD;
y /= 2;
}
return z;
}
ll inv(ll x) { return power(x, MOD - 2); }
ll divide(ll x, ll y) { return (x * inv(y)) % MOD; }
ll C(ll n, ll k) {
if (k > n)
return 0;
return divide(fact[n], (fact[n - k] * fact[k]) % MOD);
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
bool isPrime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
void init() {
ll p = MOD;
fact[0] = 1;
ll i;
for (i = 1; i < 500005; i++) {
fact[i] = (i * fact[i - 1]) % p;
}
i--;
invfact[i] = power(fact[i], p - 2);
for (i--; i >= 0; i--) {
invfact[i] = (invfact[i + 1] * (i + 1)) % p;
}
}
ll s;
ll fun(ll a) {
if (a == 0)
return 0;
return a + fun(a - 1);
}
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> gq;
#define MAXN 10000001
ll spf[MAXN];
void sieve() {
spf[1] = 1;
for (ll i = 2; i < MAXN; i++)
spf[i] = i;
for (ll i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (ll i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (ll j = i * i; j < MAXN; j += i)
if (spf[j] == j)
spf[j] = i;
}
}
}
set<ll> getFactorization(ll x) {
set<ll> ret;
while (x != 1) {
ret.insert(spf[x]);
x = x / spf[x];
}
return ret;
}
ll sm(ll n) {
ll i;
ll k = 0;
while (n > 0) {
k = k + n % 10;
n = n / 10;
}
return k;
}
vector<ll> v[100001];
ll dp[100001];
ll vis[100001];
void dfs(ll k) {
vis[k] = 1;
for (ll i = 0; i < v[k].size(); i++) {
dfs(v[k][i]);
dp[k] = max(dp[k], 1 + dp[v[k][i]]);
}
}
void ghost() {
ll i = 0, j = 0, k = 0, l = 0, n, r = 0, q = 0, y = 100000000000, m, w;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> k >> l;
v[k].pb(l);
}
for (i = 1; i <= n; i++) {
if (!vis[i])
dfs(i);
}
ll ans = 0;
for (i = 1; i <= n; i++)
ans = max(ans, dp[i]);
cout << ans << endl;
}
signed main() {
int test = 1;
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
fast
// cin>>test;
while (test--) ghost();
return 0;
}
|
using namespace std;
#include <bits/stdc++.h>
#define pb push_back
#define mk make_pair
#define vect vector<ll>
#define maap map<ll, ll>
#define MOD 1000000007
#define mit map::iterator
#define pii pair<ll, ll>
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
typedef long long int ll;
// stringstream convert;
// convert << number;
// string s = convert.str();
ll fact[500005], invfact[500005];
ll power(ll x, ll y) {
ll z = 1;
while (y > 0) {
if (y % 2 == 1)
z = (z * x) % MOD;
x = (x * x) % MOD;
y /= 2;
}
return z;
}
ll inv(ll x) { return power(x, MOD - 2); }
ll divide(ll x, ll y) { return (x * inv(y)) % MOD; }
ll C(ll n, ll k) {
if (k > n)
return 0;
return divide(fact[n], (fact[n - k] * fact[k]) % MOD);
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
bool isPrime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
void init() {
ll p = MOD;
fact[0] = 1;
ll i;
for (i = 1; i < 500005; i++) {
fact[i] = (i * fact[i - 1]) % p;
}
i--;
invfact[i] = power(fact[i], p - 2);
for (i--; i >= 0; i--) {
invfact[i] = (invfact[i + 1] * (i + 1)) % p;
}
}
ll s;
ll fun(ll a) {
if (a == 0)
return 0;
return a + fun(a - 1);
}
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> gq;
#define MAXN 10000001
ll spf[MAXN];
void sieve() {
spf[1] = 1;
for (ll i = 2; i < MAXN; i++)
spf[i] = i;
for (ll i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (ll i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (ll j = i * i; j < MAXN; j += i)
if (spf[j] == j)
spf[j] = i;
}
}
}
set<ll> getFactorization(ll x) {
set<ll> ret;
while (x != 1) {
ret.insert(spf[x]);
x = x / spf[x];
}
return ret;
}
ll sm(ll n) {
ll i;
ll k = 0;
while (n > 0) {
k = k + n % 10;
n = n / 10;
}
return k;
}
vector<ll> v[100001];
ll dp[100001];
ll vis[100001];
void dfs(ll k) {
vis[k] = 1;
for (ll i = 0; i < v[k].size(); i++) {
if (!vis[v[k][i]])
dfs(v[k][i]);
dp[k] = max(dp[k], 1 + dp[v[k][i]]);
}
}
void ghost() {
ll i = 0, j = 0, k = 0, l = 0, n, r = 0, q = 0, y = 100000000000, m, w;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> k >> l;
v[k].pb(l);
}
for (i = 1; i <= n; i++) {
if (!vis[i])
dfs(i);
}
ll ans = 0;
for (i = 1; i <= n; i++)
ans = max(ans, dp[i]);
cout << ans << endl;
}
signed main() {
int test = 1;
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
fast
// cin>>test;
while (test--) ghost();
return 0;
}
|
replace
| 117 | 118 | 117 | 119 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
vector<int> adj[100005];
vector<int> memo(100005, -1);
int dfs(int u) {
if (memo[u] != -1)
return memo[u];
int ans = 0;
for (auto it : adj[u])
ans = max(ans, 1 + dfs(it));
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].pb(v);
}
int ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, dfs(i));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
vector<int> adj[100005];
vector<int> memo(100005, -1);
int dfs(int u) {
if (memo[u] != -1)
return memo[u];
int ans = 0;
for (auto it : adj[u])
ans = max(ans, 1 + dfs(it));
return memo[u] = ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].pb(v);
}
int ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, dfs(i));
cout << ans;
return 0;
}
|
replace
| 15 | 16 | 15 | 16 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[100010];
vector<vector<int>> g;
int rec(int v) {
if (dp[v] != -1) {
return dp[v];
} else {
int ma = 0;
for (auto i : g[v]) {
ma = max(ma, rec(i) + 1);
}
return ma;
}
}
int main() {
int ans = 0;
cin >> n >> m;
g.assign(n, vector<int>());
for (int j = 0; j < m; j++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y); // xからyに行く辺
}
// 初期化
for (int i = 0; i < n; i++) {
dp[i] = -1;
}
for (int v = 0; v < n; v++) {
ans = max(ans, rec(v));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[100010];
vector<vector<int>> g;
int rec(int v) {
if (dp[v] != -1) {
return dp[v];
} else {
int ma = 0;
for (auto i : g[v]) {
ma = max(ma, rec(i) + 1);
}
return dp[v] = ma;
}
}
int main() {
int ans = 0;
cin >> n >> m;
g.assign(n, vector<int>());
for (int j = 0; j < m; j++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y); // xからyに行く辺
}
// 初期化
for (int i = 0; i < n; i++) {
dp[i] = -1;
}
for (int v = 0; v < n; v++) {
ans = max(ans, rec(v));
}
cout << ans << endl;
}
|
replace
| 12 | 13 | 12 | 13 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
// Define
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
const ll mod = 998244353;
const ll inf = 1 << 30;
const ll LINF = LONG_MAX;
const ll INF = 1LL << 60;
const ull MAX = ULONG_MAX;
#define mp make_pair
#define pb push_back
#define elif else if
#define endl '\n'
#define space ' '
#define def inline auto
#define func inline constexpr ll
#define run(a) __attribute__((constructor)) def _##a()
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define input(a) scanf("%lld", &(a))
#define print(a) printf("%lld\n", (a))
#define fi first
#define se second
#define ok(a, b) (0 <= (a) && (a) < (b))
template <class T> using vvector = vector<vector<T>>;
template <class T> using pvector = vector<pair<T, T>>;
template <class T>
using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// Debug
#define debug(...) \
{ \
cerr << __LINE__ << ": " << #__VA_ARGS__ << " = "; \
for (auto &&X : {__VA_ARGS__}) \
cerr << "[" << X << "] "; \
cerr << endl; \
}
#define dump(a, h, w) \
{ \
cerr << __LINE__ << ": " << #a << " = [" << endl; \
rep(__i, h) { \
rep(__j, w) { cerr << a[__i][__j] << space; } \
cerr << endl; \
} \
cerr << "]" << endl; \
}
#define vdump(a, n) \
{ \
cerr << __LINE__ << ": " << #a << " = ["; \
rep(__i, n) if (__i) cerr << space << a[__i]; \
else cerr << a[__i]; \
cerr << "]" << endl; \
}
// Loop
#define inc(i, a, n) for (ll i = (a), _##i = (n); i <= _##i; ++i)
#define dec(i, a, n) for (ll i = (a), _##i = (n); i >= _##i; --i)
#define rep(i, n) for (ll i = 0, _##i = (n); i < _##i; ++i)
#define each(i, a) for (auto &&i : a)
#define loop() for (;;)
// Stream
#define fout(n) cout << fixed << setprecision(n)
#define fasten cin.tie(0), ios::sync_with_stdio(0)
run(0) { fasten, fout(10); }
// Speed
#pragma GCC optimize("O3")
#pragma GCC target("avx")
// Math
func gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
func lcm(ll a, ll b) { return a / gcd(a, b) * b; }
func sign(ll a) { return a ? abs(a) / a : 0; }
inline constexpr ll modulo(const ll n, const ll m = MOD) {
ll k = n % m;
return k + m * (k < 0);
}
inline constexpr ll chmod(ll &n, const ll m = MOD) {
n %= m;
return n += m * (n < 0);
}
inline constexpr ll mpow(ll a, ll n, const ll m = MOD) {
ll r = 1;
while (n) {
if (n & 1)
r *= a;
chmod(r, m);
a *= a;
chmod(a, m);
n >>= 1;
}
return r;
}
inline ll inv(const ll n, const ll m = MOD) {
ll a = n, b = m, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return modulo(x, m);
}
struct Factor {
inline vector<ll> factors(ll N) {
vector<ll> A;
ll i = 2;
while (i * i <= N) {
if (N % i == 0) {
A.push_back(i);
N /= i;
} else {
i++;
}
}
if (N != 1)
A.push_back(N);
sort(all(A));
return A;
}
inline vector<ll> divisor(ll N) {
vector<ll> A;
inc(i, 1, sqrt(N)) {
if (N % i == 0) {
A.push_back(i);
if (i * i != N)
A.push_back(N / i);
}
}
sort(all(A));
return A;
}
};
struct csum {
ll N;
vector<ll> A, S;
csum(vector<ll> v) : A(v), S(1) { each(k, v) S.push_back(k + S.back()); }
ll sum(ll l, ll r) { return S[r] - S[l]; }
ll lsum(ll r) { return S[r]; }
ll rsum(ll l) { return S.back() - S[l]; }
};
template <ull mod = MOD> struct mi {
inline constexpr ll modulo(const ll n, const ll m) const noexcept {
ll k = n % m;
return k + m * (k < 0);
}
ll num;
inline constexpr mi() noexcept : num() { num = 0; }
inline constexpr mi(const int n) noexcept : num() { num = modulo(n, mod); }
inline constexpr mi(const ll n) noexcept : num() { num = modulo(n, mod); }
inline constexpr mi<mod> inv() const noexcept {
ll a = num, b = mod, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return mi<mod>(x);
}
inline constexpr mi<mod> inv(ll n) const noexcept {
ll a = n, b = mod, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return mi<mod>(x);
}
inline constexpr mi<mod> inv(const mi<mod> m) const noexcept {
return inv(m.num);
}
inline constexpr mi<mod> operator+() const noexcept { return mi(num); }
inline constexpr mi<mod> operator+(const int n) const noexcept {
return mi<mod>(num + n);
}
inline constexpr mi<mod> operator+(const ll n) const noexcept {
return mi<mod>(num + n);
}
inline constexpr mi<mod> operator+(const mi<mod> m) const noexcept {
return mi<mod>(num + m.num);
}
inline constexpr mi<mod> operator-() const noexcept { return -num; }
inline constexpr mi<mod> operator-(const int n) const noexcept {
return mi<mod>(num - n);
}
inline constexpr mi<mod> operator-(const ll n) const noexcept {
return mi<mod>(num - n);
}
inline constexpr mi<mod> operator-(const mi<mod> m) const noexcept {
return mi<mod>(num - m.num);
}
inline constexpr mi<mod> operator*(const int n) const noexcept {
return mi<mod>(num * n);
}
inline constexpr mi<mod> operator*(const ll n) const noexcept {
return mi<mod>(num * n);
}
inline constexpr mi<mod> operator*(const mi<mod> m) const noexcept {
return mi<mod>(num * m);
}
inline constexpr mi<mod> operator/(const int n) const noexcept {
return mi<mod>(num * (ll)inv(n));
}
inline constexpr mi<mod> operator/(const ll n) const noexcept {
return mi<mod>(num * (ll)inv(n));
}
inline constexpr mi<mod> operator/(const mi<mod> m) const noexcept {
return mi<mod>(num * (ll)inv(m));
}
inline constexpr mi<mod> &operator=(const int n) noexcept {
num = modulo(n, mod);
return *this;
}
inline constexpr mi<mod> &operator=(const ll n) noexcept {
num = modulo(n, mod);
return *this;
}
inline constexpr mi<mod> &operator=(const mi<mod> m) noexcept {
num = m.num;
return *this;
}
inline constexpr mi<mod> &operator+=(const int n) noexcept {
num = modulo(num + n, mod);
return *this;
}
inline constexpr mi<mod> &operator+=(const ll n) noexcept {
num = modulo(num + n, mod);
return *this;
}
inline constexpr mi<mod> &operator+=(const mi<mod> m) noexcept {
num = modulo(num + m.num, mod);
return *this;
}
inline constexpr mi<mod> &operator++() noexcept {
num = modulo(num + 1, mod);
return *this;
}
inline constexpr mi<mod> operator++(int) noexcept {
mi &pre = *this;
num = modulo(num + 1, mod);
return pre;
}
inline constexpr mi<mod> &operator-=(const int n) noexcept {
num = modulo(num - n, mod);
return *this;
}
inline constexpr mi<mod> &operator-=(const ll n) noexcept {
num = modulo(num - n, mod);
return *this;
}
inline constexpr mi<mod> &operator-=(const mi<mod> m) noexcept {
num = modulo(num - m.num, mod);
return *this;
}
inline constexpr mi<mod> &operator--() noexcept {
num = modulo(num - 1, mod);
return *this;
}
inline constexpr mi<mod> operator--(int) noexcept {
mi &pre = *this;
num = modulo(num - 1, mod);
return pre;
}
inline constexpr mi<mod> &operator*=(const int n) noexcept {
num = modulo(num * n, mod);
return *this;
}
inline constexpr mi<mod> &operator*=(const ll n) noexcept {
num = modulo(num * n, mod);
return *this;
}
inline constexpr mi<mod> &operator*=(const mi<mod> m) noexcept {
num = modulo(num * m.num, mod);
return *this;
}
inline constexpr mi<mod> &operator/=(const int n) noexcept {
num = modulo(num * (ll)inv(n), mod);
return *this;
}
inline constexpr mi<mod> &operator/=(const ll n) noexcept {
num = modulo(num * (ll)inv(n), mod);
return *this;
}
inline constexpr mi<mod> &operator/=(const mi<mod> m) noexcept {
num = modulo(num * (ll)inv(m), mod);
return *this;
}
inline constexpr mi<mod> operator==(const int n) const noexcept {
return num == modulo(n, mod);
}
inline constexpr mi<mod> operator==(const ll n) const noexcept {
return num == modulo(n, mod);
}
inline constexpr mi<mod> operator==(const mi<mod> m) const noexcept {
return num == m.num;
}
inline constexpr mi<mod> operator!=(const int n) const noexcept {
return num != modulo(n, mod);
}
inline constexpr mi<mod> operator!=(const ll n) const noexcept {
return num != modulo(n, mod);
}
inline constexpr mi<mod> operator!=(const mi<mod> m) const noexcept {
return num != m.num;
}
constexpr operator int() const noexcept { return num; }
constexpr operator ll() const noexcept { return num; }
friend std::istream &operator>>(std::istream &, const mi<> &);
friend std::ostream &operator<<(std::ostream &, const mi<> &);
};
template <ull mod = MOD>
inline constexpr mi<mod> operator+(const int n, const mi<mod> m) noexcept {
return mi<mod>(n + m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator+(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n + m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator-(const int n, const mi<mod> m) noexcept {
return mi<mod>(n - m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator-(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n - m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator*(const int n, const mi<mod> m) noexcept {
return mi<mod>(n * m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator*(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n * m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator/(const int n, const mi<mod> m) noexcept {
return mi<mod>(n * (ll)m.inv());
}
template <ull mod = MOD>
inline constexpr mi<mod> operator/(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n * (ll)m.inv());
}
inline constexpr mi<MOD> operator""_m(ull n) { return mi<MOD>((ll)n); }
template <ull mod = MOD>
inline constexpr mi<mod> pow(mi<mod> m, ll n) noexcept {
mi<mod> r = mi<mod>(1);
while (n) {
if (n & 1)
r *= m;
m *= m;
n >>= 1;
}
return r;
}
template <ull mod> istream &operator>>(istream &is, mi<mod> &m) {
is >> m.num;
return is;
}
template <ull mod> ostream &operator<<(ostream &is, mi<mod> &m) {
is << (ll)m;
return is;
}
template <ull mod = MOD> struct modmath {
ll max;
vector<mi<mod>> fac, inv;
modmath() : max(1 << 20), fac(max + 1), inv(max + 1) {
fac[0] = mi<mod>(1);
rep(i, max) fac[i + 1] = fac[i] * (i + 1);
inv[max] = fac[max].inv();
dec(i, max - 1, 0) inv[i] = inv[i + 1] * (i + 1);
}
modmath(ll n) : max(n), fac(n + 1), inv(n + 1) {
fac[0] = 1;
rep(i, n) fac[i + 1] = fac[i] * (i + 1);
inv[n] = 1 / fac[n];
dec(i, n - 1, 0) inv[i] = inv[i + 1] * (i + 1);
}
inline mi<mod> fact(ll n) {
if (n < 0)
return mi<mod>(0);
return fac[n];
}
inline mi<mod> perm(ll n, ll r) {
if (r < 0 || n < r)
return mi<mod>(0);
return fac[n] * inv[n - r];
}
inline mi<mod> comb(ll n, ll r) {
if (r < 0 || n < r)
return mi<mod>(0);
return fac[n] * inv[r] * inv[n - r];
}
inline mi<mod> nHr(ll n, ll r) { return comb(n + r - 1, n - 1); }
};
struct UFR {
vector<ll> data;
UFR(ll N) : data(N) { rep(i, N) data[i] = -1; }
def root(ll x) {
if (data[x] < 0)
return x;
else
return data[x] = root(data[x]);
}
def unite(ll x, ll y) {
ll root_x = root(x), root_y = root(y);
if (root_x != root_y) {
if (data[root_x] > data[root_y])
swap(root_x, root_y);
data[root_x] -= data[root_x] == data[root_y];
data[root_y] = root_x;
return true;
}
return false;
}
def same(ll x, ll y) { return root(x) == root(y); }
};
struct position {
ll x, y;
position() {}
position(ll a, ll b) : x(a), y(b) {}
position next(ll i) { return {x + dx[i], y + dy[i]}; }
ll mdist() { return abs(x) + abs(y); }
double dist() { return sqrt(x * x + y * y); }
double norm(ll d) {
if (d == inf)
return max(x, y);
if (d == 1)
return mdist();
if (d == 2)
return dist();
return 0;
}
ll num(ll width) { return abs(x) * width + abs(y); }
bool operator==(position a) { return x == a.x && y == a.y; }
bool operator!=(position a) { return x != a.x || y != a.y; }
bool operator<(position a) { return x < a.x && y < a.y; }
bool operator>(position a) { return x > a.x && y > a.y; }
bool operator<=(position a) { return x <= a.x && y <= a.y; }
bool operator>=(position a) { return x >= a.x && y >= a.y; }
position operator+(position a) { return position(x + a.x, y + a.y); }
position operator-(position a) { return position(x - a.x, y - a.y); }
position operator*(position a) { return position(x * a.x, y * a.y); }
position operator/(position a) { return position(x / a.x, y / a.y); }
position operator%(position a) { return position(x % a.x, y % a.y); }
position complex(position a) {
return position(x * a.x - y * a.y, x * a.y + y * a.x);
}
/*
// for sort:
bool operator<(position a) { return x ^ a.x ? x < a.x : y < a.y; }
bool operator>(position a) { return x ^ a.x ? x > a.x : y > a.y; }
bool operator<=(position a) { return x ^ a.x ? x < a.x : y <= a.y; }
bool operator>=(position a) { return x ^ a.x ? x > a.x : y >= a.y; }
*/
};
position Origin = position(0, 0);
using pos = position;
using vec = position;
template <class T> struct Array {
struct node {
ll childl, childr;
T data;
node(ll l, ll r, T t) : childl(l), childr(r), data(t) {}
};
ll n, depth;
vector<ll> versions;
vector<ll> prev_versions;
vector<node> nodes;
Array(ll n = 1 << 20, T val = T()) : n(n), depth(0) {
while (n /= 2)
depth++;
init(val);
}
void init(T val) {
versions.push_back(0);
prev_versions.push_back(0);
rep(i, 2 * n - 1) {
if (i < n - 1) {
nodes.push_back(node(2 * i + 1, 2 * i + 2, T()));
} else {
nodes.push_back(node(0, 0, val));
}
}
}
void set(ll index, ll val, ll version = -1) {
ll id, par = nodes.size(), left = 0, right = n;
if (version == -1) {
id = versions.back();
version = versions.size() - 1;
} else {
id = versions[version];
}
versions.push_back(par);
prev_versions.push_back(version);
if (right == -1)
right = n;
rep(i, depth) {
ll mid = (left + right) / 2;
if (index < mid) {
nodes.push_back(node(par + i + 1, nodes[id].childr, T()));
id = nodes[id].childl;
right = mid;
} else {
nodes.push_back(node(nodes[id].childl, par + i + 1, T()));
id = nodes[id].childr;
left = mid;
}
}
nodes.push_back(node(0, 0, val));
}
T get(ll index, ll version = -1) {
ll id, left = 0, right = n;
if (version == -1) {
id = versions.back();
} else {
id = versions[version];
}
rep(i, depth) {
ll mid = (left + right) / 2;
if (index < mid) {
id = nodes[id].childl;
right = mid;
} else {
id = nodes[id].childr;
left = mid;
}
}
return nodes[id].data;
}
ll latest() { return versions.size() - 1; }
};
struct BipartiteGraph {
ll V;
vector<vector<ll>> G;
vector<ll> match;
vector<bool> used;
BipartiteGraph(ll N) : V(N), G(N), match(N), used(N) {}
void addEdge(ll i, ll j) {
G[i].push_back(j);
G[j].push_back(i);
}
bool dfs(ll now) {
used[now] = true;
rep(i, G[now].size()) {
ll next = G[now][i], w = match[next];
if (w == -1 || (!used[w] && dfs(w))) {
match[now] = next, match[next] = now;
return true;
}
}
return false;
}
ll matching() {
ll res = 0;
fill(all(match), -1);
rep(i, V) {
if (match[i] == -1) {
fill(all(used), false);
if (dfs(i))
res++;
}
}
return res;
}
};
template <typename T = ll> struct Dijkstra {
ll V;
using P = pair<ll, ll>;
vector<vector<P>> G;
vector<T> dist;
vector<bool> used;
Dijkstra(ll v) : V(v), G(v), dist(v), used(v) {}
void setDist(ll a, ll b, ll d) { G[a].push_back(P(d, b)); }
void culc(ll s = 0) {
priority_queue<P, vector<P>, greater<P>> Q;
Q.push(P(0, s));
fill_n(dist.begin(), V, INF);
fill_n(used.begin(), V, false);
while (!Q.empty()) {
T d;
ll t;
tie(d, t) = Q.top(), Q.pop();
if (used[t])
continue;
used[t] = true, dist[t] = d;
for (P e : G[t]) {
if (dist[e.second] <= d + e.first)
continue;
Q.push(P(d + e.first, e.second));
}
}
}
};
signed main() {
ll N, M, A, B;
cin >> N >> M;
vector<ll> G[N];
rep(i, M) cin >> A >> B, G[A - 1].pb(B - 1);
ll res = 0, dist[N];
rep(i, N) dist[i] = -1;
function<ll(ll)> dfs = [&](ll i) {
if (dist[i] != -1)
return dist[i];
ll res = 0;
each(to, G[i]) chmax(res, dfs(to) + 1);
return res;
};
rep(i, N) chmax(res, dfs(i));
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
// Define
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
const ll mod = 998244353;
const ll inf = 1 << 30;
const ll LINF = LONG_MAX;
const ll INF = 1LL << 60;
const ull MAX = ULONG_MAX;
#define mp make_pair
#define pb push_back
#define elif else if
#define endl '\n'
#define space ' '
#define def inline auto
#define func inline constexpr ll
#define run(a) __attribute__((constructor)) def _##a()
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define input(a) scanf("%lld", &(a))
#define print(a) printf("%lld\n", (a))
#define fi first
#define se second
#define ok(a, b) (0 <= (a) && (a) < (b))
template <class T> using vvector = vector<vector<T>>;
template <class T> using pvector = vector<pair<T, T>>;
template <class T>
using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// Debug
#define debug(...) \
{ \
cerr << __LINE__ << ": " << #__VA_ARGS__ << " = "; \
for (auto &&X : {__VA_ARGS__}) \
cerr << "[" << X << "] "; \
cerr << endl; \
}
#define dump(a, h, w) \
{ \
cerr << __LINE__ << ": " << #a << " = [" << endl; \
rep(__i, h) { \
rep(__j, w) { cerr << a[__i][__j] << space; } \
cerr << endl; \
} \
cerr << "]" << endl; \
}
#define vdump(a, n) \
{ \
cerr << __LINE__ << ": " << #a << " = ["; \
rep(__i, n) if (__i) cerr << space << a[__i]; \
else cerr << a[__i]; \
cerr << "]" << endl; \
}
// Loop
#define inc(i, a, n) for (ll i = (a), _##i = (n); i <= _##i; ++i)
#define dec(i, a, n) for (ll i = (a), _##i = (n); i >= _##i; --i)
#define rep(i, n) for (ll i = 0, _##i = (n); i < _##i; ++i)
#define each(i, a) for (auto &&i : a)
#define loop() for (;;)
// Stream
#define fout(n) cout << fixed << setprecision(n)
#define fasten cin.tie(0), ios::sync_with_stdio(0)
run(0) { fasten, fout(10); }
// Speed
#pragma GCC optimize("O3")
#pragma GCC target("avx")
// Math
func gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
func lcm(ll a, ll b) { return a / gcd(a, b) * b; }
func sign(ll a) { return a ? abs(a) / a : 0; }
inline constexpr ll modulo(const ll n, const ll m = MOD) {
ll k = n % m;
return k + m * (k < 0);
}
inline constexpr ll chmod(ll &n, const ll m = MOD) {
n %= m;
return n += m * (n < 0);
}
inline constexpr ll mpow(ll a, ll n, const ll m = MOD) {
ll r = 1;
while (n) {
if (n & 1)
r *= a;
chmod(r, m);
a *= a;
chmod(a, m);
n >>= 1;
}
return r;
}
inline ll inv(const ll n, const ll m = MOD) {
ll a = n, b = m, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return modulo(x, m);
}
struct Factor {
inline vector<ll> factors(ll N) {
vector<ll> A;
ll i = 2;
while (i * i <= N) {
if (N % i == 0) {
A.push_back(i);
N /= i;
} else {
i++;
}
}
if (N != 1)
A.push_back(N);
sort(all(A));
return A;
}
inline vector<ll> divisor(ll N) {
vector<ll> A;
inc(i, 1, sqrt(N)) {
if (N % i == 0) {
A.push_back(i);
if (i * i != N)
A.push_back(N / i);
}
}
sort(all(A));
return A;
}
};
struct csum {
ll N;
vector<ll> A, S;
csum(vector<ll> v) : A(v), S(1) { each(k, v) S.push_back(k + S.back()); }
ll sum(ll l, ll r) { return S[r] - S[l]; }
ll lsum(ll r) { return S[r]; }
ll rsum(ll l) { return S.back() - S[l]; }
};
template <ull mod = MOD> struct mi {
inline constexpr ll modulo(const ll n, const ll m) const noexcept {
ll k = n % m;
return k + m * (k < 0);
}
ll num;
inline constexpr mi() noexcept : num() { num = 0; }
inline constexpr mi(const int n) noexcept : num() { num = modulo(n, mod); }
inline constexpr mi(const ll n) noexcept : num() { num = modulo(n, mod); }
inline constexpr mi<mod> inv() const noexcept {
ll a = num, b = mod, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return mi<mod>(x);
}
inline constexpr mi<mod> inv(ll n) const noexcept {
ll a = n, b = mod, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return mi<mod>(x);
}
inline constexpr mi<mod> inv(const mi<mod> m) const noexcept {
return inv(m.num);
}
inline constexpr mi<mod> operator+() const noexcept { return mi(num); }
inline constexpr mi<mod> operator+(const int n) const noexcept {
return mi<mod>(num + n);
}
inline constexpr mi<mod> operator+(const ll n) const noexcept {
return mi<mod>(num + n);
}
inline constexpr mi<mod> operator+(const mi<mod> m) const noexcept {
return mi<mod>(num + m.num);
}
inline constexpr mi<mod> operator-() const noexcept { return -num; }
inline constexpr mi<mod> operator-(const int n) const noexcept {
return mi<mod>(num - n);
}
inline constexpr mi<mod> operator-(const ll n) const noexcept {
return mi<mod>(num - n);
}
inline constexpr mi<mod> operator-(const mi<mod> m) const noexcept {
return mi<mod>(num - m.num);
}
inline constexpr mi<mod> operator*(const int n) const noexcept {
return mi<mod>(num * n);
}
inline constexpr mi<mod> operator*(const ll n) const noexcept {
return mi<mod>(num * n);
}
inline constexpr mi<mod> operator*(const mi<mod> m) const noexcept {
return mi<mod>(num * m);
}
inline constexpr mi<mod> operator/(const int n) const noexcept {
return mi<mod>(num * (ll)inv(n));
}
inline constexpr mi<mod> operator/(const ll n) const noexcept {
return mi<mod>(num * (ll)inv(n));
}
inline constexpr mi<mod> operator/(const mi<mod> m) const noexcept {
return mi<mod>(num * (ll)inv(m));
}
inline constexpr mi<mod> &operator=(const int n) noexcept {
num = modulo(n, mod);
return *this;
}
inline constexpr mi<mod> &operator=(const ll n) noexcept {
num = modulo(n, mod);
return *this;
}
inline constexpr mi<mod> &operator=(const mi<mod> m) noexcept {
num = m.num;
return *this;
}
inline constexpr mi<mod> &operator+=(const int n) noexcept {
num = modulo(num + n, mod);
return *this;
}
inline constexpr mi<mod> &operator+=(const ll n) noexcept {
num = modulo(num + n, mod);
return *this;
}
inline constexpr mi<mod> &operator+=(const mi<mod> m) noexcept {
num = modulo(num + m.num, mod);
return *this;
}
inline constexpr mi<mod> &operator++() noexcept {
num = modulo(num + 1, mod);
return *this;
}
inline constexpr mi<mod> operator++(int) noexcept {
mi &pre = *this;
num = modulo(num + 1, mod);
return pre;
}
inline constexpr mi<mod> &operator-=(const int n) noexcept {
num = modulo(num - n, mod);
return *this;
}
inline constexpr mi<mod> &operator-=(const ll n) noexcept {
num = modulo(num - n, mod);
return *this;
}
inline constexpr mi<mod> &operator-=(const mi<mod> m) noexcept {
num = modulo(num - m.num, mod);
return *this;
}
inline constexpr mi<mod> &operator--() noexcept {
num = modulo(num - 1, mod);
return *this;
}
inline constexpr mi<mod> operator--(int) noexcept {
mi &pre = *this;
num = modulo(num - 1, mod);
return pre;
}
inline constexpr mi<mod> &operator*=(const int n) noexcept {
num = modulo(num * n, mod);
return *this;
}
inline constexpr mi<mod> &operator*=(const ll n) noexcept {
num = modulo(num * n, mod);
return *this;
}
inline constexpr mi<mod> &operator*=(const mi<mod> m) noexcept {
num = modulo(num * m.num, mod);
return *this;
}
inline constexpr mi<mod> &operator/=(const int n) noexcept {
num = modulo(num * (ll)inv(n), mod);
return *this;
}
inline constexpr mi<mod> &operator/=(const ll n) noexcept {
num = modulo(num * (ll)inv(n), mod);
return *this;
}
inline constexpr mi<mod> &operator/=(const mi<mod> m) noexcept {
num = modulo(num * (ll)inv(m), mod);
return *this;
}
inline constexpr mi<mod> operator==(const int n) const noexcept {
return num == modulo(n, mod);
}
inline constexpr mi<mod> operator==(const ll n) const noexcept {
return num == modulo(n, mod);
}
inline constexpr mi<mod> operator==(const mi<mod> m) const noexcept {
return num == m.num;
}
inline constexpr mi<mod> operator!=(const int n) const noexcept {
return num != modulo(n, mod);
}
inline constexpr mi<mod> operator!=(const ll n) const noexcept {
return num != modulo(n, mod);
}
inline constexpr mi<mod> operator!=(const mi<mod> m) const noexcept {
return num != m.num;
}
constexpr operator int() const noexcept { return num; }
constexpr operator ll() const noexcept { return num; }
friend std::istream &operator>>(std::istream &, const mi<> &);
friend std::ostream &operator<<(std::ostream &, const mi<> &);
};
template <ull mod = MOD>
inline constexpr mi<mod> operator+(const int n, const mi<mod> m) noexcept {
return mi<mod>(n + m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator+(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n + m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator-(const int n, const mi<mod> m) noexcept {
return mi<mod>(n - m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator-(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n - m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator*(const int n, const mi<mod> m) noexcept {
return mi<mod>(n * m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator*(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n * m.num);
}
template <ull mod = MOD>
inline constexpr mi<mod> operator/(const int n, const mi<mod> m) noexcept {
return mi<mod>(n * (ll)m.inv());
}
template <ull mod = MOD>
inline constexpr mi<mod> operator/(const ll n, const mi<mod> m) noexcept {
return mi<mod>(n * (ll)m.inv());
}
inline constexpr mi<MOD> operator""_m(ull n) { return mi<MOD>((ll)n); }
template <ull mod = MOD>
inline constexpr mi<mod> pow(mi<mod> m, ll n) noexcept {
mi<mod> r = mi<mod>(1);
while (n) {
if (n & 1)
r *= m;
m *= m;
n >>= 1;
}
return r;
}
template <ull mod> istream &operator>>(istream &is, mi<mod> &m) {
is >> m.num;
return is;
}
template <ull mod> ostream &operator<<(ostream &is, mi<mod> &m) {
is << (ll)m;
return is;
}
template <ull mod = MOD> struct modmath {
ll max;
vector<mi<mod>> fac, inv;
modmath() : max(1 << 20), fac(max + 1), inv(max + 1) {
fac[0] = mi<mod>(1);
rep(i, max) fac[i + 1] = fac[i] * (i + 1);
inv[max] = fac[max].inv();
dec(i, max - 1, 0) inv[i] = inv[i + 1] * (i + 1);
}
modmath(ll n) : max(n), fac(n + 1), inv(n + 1) {
fac[0] = 1;
rep(i, n) fac[i + 1] = fac[i] * (i + 1);
inv[n] = 1 / fac[n];
dec(i, n - 1, 0) inv[i] = inv[i + 1] * (i + 1);
}
inline mi<mod> fact(ll n) {
if (n < 0)
return mi<mod>(0);
return fac[n];
}
inline mi<mod> perm(ll n, ll r) {
if (r < 0 || n < r)
return mi<mod>(0);
return fac[n] * inv[n - r];
}
inline mi<mod> comb(ll n, ll r) {
if (r < 0 || n < r)
return mi<mod>(0);
return fac[n] * inv[r] * inv[n - r];
}
inline mi<mod> nHr(ll n, ll r) { return comb(n + r - 1, n - 1); }
};
struct UFR {
vector<ll> data;
UFR(ll N) : data(N) { rep(i, N) data[i] = -1; }
def root(ll x) {
if (data[x] < 0)
return x;
else
return data[x] = root(data[x]);
}
def unite(ll x, ll y) {
ll root_x = root(x), root_y = root(y);
if (root_x != root_y) {
if (data[root_x] > data[root_y])
swap(root_x, root_y);
data[root_x] -= data[root_x] == data[root_y];
data[root_y] = root_x;
return true;
}
return false;
}
def same(ll x, ll y) { return root(x) == root(y); }
};
struct position {
ll x, y;
position() {}
position(ll a, ll b) : x(a), y(b) {}
position next(ll i) { return {x + dx[i], y + dy[i]}; }
ll mdist() { return abs(x) + abs(y); }
double dist() { return sqrt(x * x + y * y); }
double norm(ll d) {
if (d == inf)
return max(x, y);
if (d == 1)
return mdist();
if (d == 2)
return dist();
return 0;
}
ll num(ll width) { return abs(x) * width + abs(y); }
bool operator==(position a) { return x == a.x && y == a.y; }
bool operator!=(position a) { return x != a.x || y != a.y; }
bool operator<(position a) { return x < a.x && y < a.y; }
bool operator>(position a) { return x > a.x && y > a.y; }
bool operator<=(position a) { return x <= a.x && y <= a.y; }
bool operator>=(position a) { return x >= a.x && y >= a.y; }
position operator+(position a) { return position(x + a.x, y + a.y); }
position operator-(position a) { return position(x - a.x, y - a.y); }
position operator*(position a) { return position(x * a.x, y * a.y); }
position operator/(position a) { return position(x / a.x, y / a.y); }
position operator%(position a) { return position(x % a.x, y % a.y); }
position complex(position a) {
return position(x * a.x - y * a.y, x * a.y + y * a.x);
}
/*
// for sort:
bool operator<(position a) { return x ^ a.x ? x < a.x : y < a.y; }
bool operator>(position a) { return x ^ a.x ? x > a.x : y > a.y; }
bool operator<=(position a) { return x ^ a.x ? x < a.x : y <= a.y; }
bool operator>=(position a) { return x ^ a.x ? x > a.x : y >= a.y; }
*/
};
position Origin = position(0, 0);
using pos = position;
using vec = position;
template <class T> struct Array {
struct node {
ll childl, childr;
T data;
node(ll l, ll r, T t) : childl(l), childr(r), data(t) {}
};
ll n, depth;
vector<ll> versions;
vector<ll> prev_versions;
vector<node> nodes;
Array(ll n = 1 << 20, T val = T()) : n(n), depth(0) {
while (n /= 2)
depth++;
init(val);
}
void init(T val) {
versions.push_back(0);
prev_versions.push_back(0);
rep(i, 2 * n - 1) {
if (i < n - 1) {
nodes.push_back(node(2 * i + 1, 2 * i + 2, T()));
} else {
nodes.push_back(node(0, 0, val));
}
}
}
void set(ll index, ll val, ll version = -1) {
ll id, par = nodes.size(), left = 0, right = n;
if (version == -1) {
id = versions.back();
version = versions.size() - 1;
} else {
id = versions[version];
}
versions.push_back(par);
prev_versions.push_back(version);
if (right == -1)
right = n;
rep(i, depth) {
ll mid = (left + right) / 2;
if (index < mid) {
nodes.push_back(node(par + i + 1, nodes[id].childr, T()));
id = nodes[id].childl;
right = mid;
} else {
nodes.push_back(node(nodes[id].childl, par + i + 1, T()));
id = nodes[id].childr;
left = mid;
}
}
nodes.push_back(node(0, 0, val));
}
T get(ll index, ll version = -1) {
ll id, left = 0, right = n;
if (version == -1) {
id = versions.back();
} else {
id = versions[version];
}
rep(i, depth) {
ll mid = (left + right) / 2;
if (index < mid) {
id = nodes[id].childl;
right = mid;
} else {
id = nodes[id].childr;
left = mid;
}
}
return nodes[id].data;
}
ll latest() { return versions.size() - 1; }
};
struct BipartiteGraph {
ll V;
vector<vector<ll>> G;
vector<ll> match;
vector<bool> used;
BipartiteGraph(ll N) : V(N), G(N), match(N), used(N) {}
void addEdge(ll i, ll j) {
G[i].push_back(j);
G[j].push_back(i);
}
bool dfs(ll now) {
used[now] = true;
rep(i, G[now].size()) {
ll next = G[now][i], w = match[next];
if (w == -1 || (!used[w] && dfs(w))) {
match[now] = next, match[next] = now;
return true;
}
}
return false;
}
ll matching() {
ll res = 0;
fill(all(match), -1);
rep(i, V) {
if (match[i] == -1) {
fill(all(used), false);
if (dfs(i))
res++;
}
}
return res;
}
};
template <typename T = ll> struct Dijkstra {
ll V;
using P = pair<ll, ll>;
vector<vector<P>> G;
vector<T> dist;
vector<bool> used;
Dijkstra(ll v) : V(v), G(v), dist(v), used(v) {}
void setDist(ll a, ll b, ll d) { G[a].push_back(P(d, b)); }
void culc(ll s = 0) {
priority_queue<P, vector<P>, greater<P>> Q;
Q.push(P(0, s));
fill_n(dist.begin(), V, INF);
fill_n(used.begin(), V, false);
while (!Q.empty()) {
T d;
ll t;
tie(d, t) = Q.top(), Q.pop();
if (used[t])
continue;
used[t] = true, dist[t] = d;
for (P e : G[t]) {
if (dist[e.second] <= d + e.first)
continue;
Q.push(P(d + e.first, e.second));
}
}
}
};
signed main() {
ll N, M, A, B;
cin >> N >> M;
vector<ll> G[N];
rep(i, M) cin >> A >> B, G[A - 1].pb(B - 1);
ll res = 0, dist[N];
rep(i, N) dist[i] = -1;
function<ll(ll)> dfs = [&](ll i) {
if (dist[i] != -1)
return dist[i];
ll res = 0;
each(to, G[i]) chmax(res, dfs(to) + 1);
return dist[i] = res;
};
rep(i, N) chmax(res, dfs(i));
cout << res << endl;
}
|
replace
| 655 | 656 | 655 | 656 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <utility>
using namespace std;
#define FIN \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pb push_back
#define fore(i, a, b) for (int i = a; i < b; i++)
#define rfor(i, a, b) for (int i = a - 1; i >= b; i--)
ll n, m;
ll dp[100010];
bool visited[100010];
vector<int> g[100010];
ll dfs(int node) {
// if(dp[node] != -1)return dp[node];
ll ma = 0;
for (auto x : g[node]) {
ma = max(ma, dfs(x) + 1);
}
dp[node] = ma;
return dp[node];
}
int main() {
cin >> n >> m;
fore(i, 0, m) {
int v, w;
cin >> v >> w;
g[v].push_back(w);
visited[w] = true;
}
fore(i, 1, n + 1) dp[i] = -1;
fore(i, 1, n + 1) {
if (!visited[i])
dfs(i);
}
ll ma = 0;
// fore(i,1,n+1)cout<<dp[i]<<" ";
// cout<<endl;
fore(i, 1, n + 1) ma = max(ma, dp[i]);
cout << ma << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <utility>
using namespace std;
#define FIN \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pb push_back
#define fore(i, a, b) for (int i = a; i < b; i++)
#define rfor(i, a, b) for (int i = a - 1; i >= b; i--)
ll n, m;
ll dp[100010];
bool visited[100010];
vector<int> g[100010];
ll dfs(int node) {
if (dp[node] != -1)
return dp[node];
ll ma = 0;
for (auto x : g[node]) {
ma = max(ma, dfs(x) + 1);
}
dp[node] = ma;
return dp[node];
}
int main() {
cin >> n >> m;
fore(i, 0, m) {
int v, w;
cin >> v >> w;
g[v].push_back(w);
visited[w] = true;
}
fore(i, 1, n + 1) dp[i] = -1;
fore(i, 1, n + 1) {
if (!visited[i])
dfs(i);
}
ll ma = 0;
// fore(i,1,n+1)cout<<dp[i]<<" ";
// cout<<endl;
fore(i, 1, n + 1) ma = max(ma, dp[i]);
cout << ma << endl;
return 0;
}
|
replace
| 19 | 20 | 19 | 21 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1000];
int dp[100005];
int n, m;
int lp(int n) {
int &ret = dp[n];
if (ret != -1)
return ret;
ret = 0;
for (int i = 0; i < adj[n].size(); i++) {
ret = max(ret, lp(adj[n][i]) + 1);
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
memset(dp, -1, sizeof dp);
int mx = -1;
for (int i = 1; i <= n; i++) {
mx = max(mx, lp(i));
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
int dp[100005];
int n, m;
int lp(int n) {
int &ret = dp[n];
if (ret != -1)
return ret;
ret = 0;
for (int i = 0; i < adj[n].size(); i++) {
ret = max(ret, lp(adj[n][i]) + 1);
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
memset(dp, -1, sizeof dp);
int mx = -1;
for (int i = 1; i <= n; i++) {
mx = max(mx, lp(i));
}
cout << mx << endl;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p03166
|
C++
|
Runtime Error
|
/**
* author: Atreus
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 3e3 + 10;
vector<int> g[maxn], topol;
bool visited[maxn];
int dp[maxn];
void dfs(int v) {
visited[v] = 1;
for (auto u : g[v])
if (!visited[u])
dfs(u);
topol.push_back(v);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
g[v].push_back(u);
}
for (int v = 1; v <= n; v++)
if (!visited[v])
dfs(v);
for (auto v : topol) {
for (auto u : g[v]) {
dp[v] = max(dp[v], dp[u] + 1);
}
}
cout << *max_element(dp + 1, dp + n + 1) << endl;
}
|
/**
* author: Atreus
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 10;
vector<int> g[maxn], topol;
bool visited[maxn];
int dp[maxn];
void dfs(int v) {
visited[v] = 1;
for (auto u : g[v])
if (!visited[u])
dfs(u);
topol.push_back(v);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
g[v].push_back(u);
}
for (int v = 1; v <= n; v++)
if (!visited[v])
dfs(v);
for (auto v : topol) {
for (auto u : g[v]) {
dp[v] = max(dp[v], dp[u] + 1);
}
}
cout << *max_element(dp + 1, dp + n + 1) << endl;
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include "algorithm"
#include "bitset"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
const long long int MOD = 1000000007;
long long int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
vector<vector<int>> edge(N);
vector<set<int>> ie(N);
vector<int> dp(N);
for (int i = 0; i < M; i++) {
cin >> L >> R;
L--;
R--;
edge[L].push_back(R);
ie[R].insert(L);
}
queue<int> Q;
for (int i = 0; i < M; i++) {
if (ie[i].empty()) {
Q.push(i);
}
}
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto i : edge[cn]) {
dp[i] = max(dp[i], dp[cn] + 1);
ie[i].erase(cn);
if (ie[i].empty())
Q.push(i);
}
}
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}
|
#include "algorithm"
#include "bitset"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
const long long int MOD = 1000000007;
long long int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
vector<vector<int>> edge(N);
vector<set<int>> ie(N);
vector<int> dp(N);
for (int i = 0; i < M; i++) {
cin >> L >> R;
L--;
R--;
edge[L].push_back(R);
ie[R].insert(L);
}
queue<int> Q;
for (int i = 0; i < N; i++) {
if (ie[i].empty()) {
Q.push(i);
}
}
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto i : edge[cn]) {
dp[i] = max(dp[i], dp[cn] + 1);
ie[i].erase(cn);
if (ie[i].empty())
Q.push(i);
}
}
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}
|
replace
| 41 | 42 | 41 | 42 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> g[11000];
ll dp[11000];
ll solve(ll u) {
if (dp[u] != -1)
return dp[u];
ll ret = 0;
for (ll i = 0; i < g[u].size(); i++) {
ret = max(ret, solve(g[u][i]) + 1);
}
return dp[u] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
}
for (ll i = 0; i < n; i++) {
dp[i] = -1;
}
ll ret = 0;
for (ll i = 0; i < n; i++) {
ret = max(ret, solve(i));
}
cout << ret << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> g[110000];
ll dp[110000];
ll solve(ll u) {
if (dp[u] != -1)
return dp[u];
ll ret = 0;
for (ll i = 0; i < g[u].size(); i++) {
ret = max(ret, solve(g[u][i]) + 1);
}
return dp[u] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
}
for (ll i = 0; i < n; i++) {
dp[i] = -1;
}
ll ret = 0;
for (ll i = 0; i < n; i++) {
ret = max(ret, solve(i));
}
cout << ret << '\n';
return 0;
}
|
replace
| 3 | 5 | 3 | 5 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define ll long long int
#define fast ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
#define MOD 1000000007
#define pb push_back
#define S second
#define F first
#define P pair<ll, ll>
#define PI 3.1415926535897932384626433832795028
// #define ordered_set tree<ll, null_type,less_equal<>,
// rb_tree_tag,tree_order_statistics_node_update>
int mul(int a, int b) { return (long long)a * b % MOD; }
int power(int a, int b) {
int ans = 1;
while (b > 0) {
if (b & 1)
ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
// bitset<400000010> b;
// ll n=100000;
ll p[1000100] = {0};
vector<ll> v[1000000];
void sieve(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (!p[i])
// primes.push_back(i);
for (ll j = i; j <= n; j += i) {
if (i != j)
;
p[j] = 1;
}
}
}
// ll nextPowerOf2(ll n)
// {
// ll p = 1;
// if (n && !(n & (n - 1)))
// return n;
// while (p < n)
// p <<= 1;
// return p;
// }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll factorial(ll n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
struct segmenttree {
vector<int> st;
int n;
void init(int _n) {
n = _n;
st.clear();
st.resize(4 * _n, 0);
}
void update(int l, int r, int indup, int val, int node) {
if (l == r) {
st[node] += val;
return;
} else {
int mid = (l + r) / 2;
if (indup >= l && indup <= mid) {
update(l, mid, indup, val, node * 2 + 1);
} else {
update(mid + 1, r, indup, val, node * 2 + 2);
}
st[node] = st[2 * node + 1] + st[2 * node + 2];
}
}
int query(int si, int se, int l, int r, int node) {
if (se < l || si > r || l > r) {
return 0;
}
if (si >= l && se <= r) {
return st[node];
}
int mid = (si + se) / 2;
int q1 = query(si, mid, l, r, node * 2 + 1);
int q2 = query(mid + 1, se, l, r, node * 2 + 2);
return q1 + q2;
}
int query(int l, int r) { return query(0, n - 1, l, r, 0); }
void update(int index, int val) { update(0, n - 1, index, val, 0); }
} tree;
bool chkcow(ll n, vector<ll> &a, ll k, ll mis) {
ll sum = 0;
for (ll i = 0; i < n; i++) {
if (a[i] > mis)
sum += a[i] - mis;
if (sum >= k)
return true;
}
return false;
}
struct cmp {
bool operator()(const pair<ll, ll> &a, const pair<ll, ll> &b) const {
ll lena = a.S - a.F;
ll lenb = b.S - b.F;
if (lena == lenb)
return a.F < b.F;
return lena > lenb;
}
};
vector<ll> graph[100000];
ll dp[100001];
ll solv(ll node) {
if (dp[node] != -1)
return dp[node];
bool leaf = 1;
ll best = 0;
for (auto child : graph[node]) {
leaf = 0;
best = max(best, solv(child));
}
return leaf ? 0 : 1 + best;
}
int32_t main() {
fast
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
// ll t;
// cin >> t;
// while (t--) {
ll n,
m;
cin >> n >> m;
memset(dp, -1, sizeof dp);
for (ll i = 0; i < m; i++) {
ll u, v;
cin >> u >> v;
graph[u].pb(v);
}
ll ans = 0;
for (ll i = 1; i <= n; i++) {
ans = max(ans, solv(i));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define ll long long int
#define fast ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
#define MOD 1000000007
#define pb push_back
#define S second
#define F first
#define P pair<ll, ll>
#define PI 3.1415926535897932384626433832795028
// #define ordered_set tree<ll, null_type,less_equal<>,
// rb_tree_tag,tree_order_statistics_node_update>
int mul(int a, int b) { return (long long)a * b % MOD; }
int power(int a, int b) {
int ans = 1;
while (b > 0) {
if (b & 1)
ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
// bitset<400000010> b;
// ll n=100000;
ll p[1000100] = {0};
vector<ll> v[1000000];
void sieve(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (!p[i])
// primes.push_back(i);
for (ll j = i; j <= n; j += i) {
if (i != j)
;
p[j] = 1;
}
}
}
// ll nextPowerOf2(ll n)
// {
// ll p = 1;
// if (n && !(n & (n - 1)))
// return n;
// while (p < n)
// p <<= 1;
// return p;
// }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll factorial(ll n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
struct segmenttree {
vector<int> st;
int n;
void init(int _n) {
n = _n;
st.clear();
st.resize(4 * _n, 0);
}
void update(int l, int r, int indup, int val, int node) {
if (l == r) {
st[node] += val;
return;
} else {
int mid = (l + r) / 2;
if (indup >= l && indup <= mid) {
update(l, mid, indup, val, node * 2 + 1);
} else {
update(mid + 1, r, indup, val, node * 2 + 2);
}
st[node] = st[2 * node + 1] + st[2 * node + 2];
}
}
int query(int si, int se, int l, int r, int node) {
if (se < l || si > r || l > r) {
return 0;
}
if (si >= l && se <= r) {
return st[node];
}
int mid = (si + se) / 2;
int q1 = query(si, mid, l, r, node * 2 + 1);
int q2 = query(mid + 1, se, l, r, node * 2 + 2);
return q1 + q2;
}
int query(int l, int r) { return query(0, n - 1, l, r, 0); }
void update(int index, int val) { update(0, n - 1, index, val, 0); }
} tree;
bool chkcow(ll n, vector<ll> &a, ll k, ll mis) {
ll sum = 0;
for (ll i = 0; i < n; i++) {
if (a[i] > mis)
sum += a[i] - mis;
if (sum >= k)
return true;
}
return false;
}
struct cmp {
bool operator()(const pair<ll, ll> &a, const pair<ll, ll> &b) const {
ll lena = a.S - a.F;
ll lenb = b.S - b.F;
if (lena == lenb)
return a.F < b.F;
return lena > lenb;
}
};
vector<ll> graph[100000];
ll dp[100001];
ll solv(ll node) {
if (dp[node] != -1)
return dp[node];
bool leaf = 1;
ll best = 0;
for (auto child : graph[node]) {
leaf = 0;
best = max(best, solv(child));
}
return dp[node] = leaf ? 0 : 1 + best;
}
int32_t main() {
fast
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
// ll t;
// cin >> t;
// while (t--) {
ll n,
m;
cin >> n >> m;
memset(dp, -1, sizeof dp);
for (ll i = 0; i < m; i++) {
ll u, v;
cin >> u >> v;
graph[u].pb(v);
}
ll ans = 0;
for (ll i = 1; i <= n; i++) {
ans = max(ans, solv(i));
}
cout << ans << endl;
return 0;
}
|
replace
| 140 | 141 | 140 | 141 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define sz(x) (int)x.size()
#define endl '\n'
#define hell 1000000007
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
// Most important thing in CP - Have Fun :)
vi adj[100005];
int depth[100005];
int n, m;
int mx = 0;
int dfs(int u) {
if (depth[u] != -1)
return depth[u];
int ans = 0;
for (int v : adj[u]) {
ans = max(ans, 1 + dfs(v));
}
mx = max(ans, mx);
return ans;
}
void solve() {
// write here
memset(depth, -1, sizeof(depth));
cin >> n >> m;
rep(i, 0, m) {
int u, v;
cin >> u >> v;
adj[u].pb(v);
}
for (int i = 1; i <= n; i++) {
dfs(i);
}
cout << mx << endl;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
// insert code
solve();
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define sz(x) (int)x.size()
#define endl '\n'
#define hell 1000000007
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
// Most important thing in CP - Have Fun :)
vi adj[100005];
int depth[100005];
int n, m;
int mx = 0;
int dfs(int u) {
if (depth[u] != -1)
return depth[u];
int ans = 0;
for (int v : adj[u]) {
ans = max(ans, 1 + dfs(v));
}
mx = max(ans, mx);
return depth[u] = ans;
}
void solve() {
// write here
memset(depth, -1, sizeof(depth));
cin >> n >> m;
rep(i, 0, m) {
int u, v;
cin >> u >> v;
adj[u].pb(v);
}
for (int i = 1; i <= n; i++) {
dfs(i);
}
cout << mx << endl;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
// insert code
solve();
return 0;
}
|
replace
| 31 | 32 | 31 | 32 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <math.h>
#include <stdio.h>
using namespace std;
using vi = vector<int>;
using vll = vector<long long int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long int>>;
using ll = long long int;
ll dp[1000000];
vb ald(1000000, false);
ll mem(ll i, const vvll &e) {
if (ald[i]) {
return dp[i];
}
if (e[i].size() == 0) {
return 0;
}
ll k = 0;
for (auto x : e[i]) {
dp[x] = mem(x, e);
if (dp[x] > k) {
k = dp[x];
}
}
dp[i] = k + 1;
return k + 1;
}
int main() {
ll N, M;
cin >> N >> M;
vvll edge(N + 1, vll(0));
for (int i = 0; i < M; i++) {
ll a, b;
cin >> a >> b;
edge[a].emplace_back(b);
}
for (int i = 1; i < N + 1; i++) {
dp[i] = 0;
}
for (int i = 1; i < N + 1; i++) {
dp[i] = mem(i, edge);
}
ll max = 0;
for (int i = 1; i < N + 1; i++) {
if (max < dp[i]) {
max = dp[i];
}
}
cout << max;
}
|
#include <bits/stdc++.h>
#include <math.h>
#include <stdio.h>
using namespace std;
using vi = vector<int>;
using vll = vector<long long int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long int>>;
using ll = long long int;
ll dp[1000000];
vb ald(1000000, false);
ll mem(ll i, const vvll &e) {
if (ald[i]) {
return dp[i];
}
if (e[i].size() == 0) {
return 0;
}
ll k = 0;
for (auto x : e[i]) {
dp[x] = mem(x, e);
ald[x] = true;
if (dp[x] > k) {
k = dp[x];
}
}
dp[i] = k + 1;
return k + 1;
}
int main() {
ll N, M;
cin >> N >> M;
vvll edge(N + 1, vll(0));
for (int i = 0; i < M; i++) {
ll a, b;
cin >> a >> b;
edge[a].emplace_back(b);
}
for (int i = 1; i < N + 1; i++) {
dp[i] = 0;
}
for (int i = 1; i < N + 1; i++) {
dp[i] = mem(i, edge);
}
ll max = 0;
for (int i = 1; i < N + 1; i++) {
if (max < dp[i]) {
max = dp[i];
}
}
cout << max;
}
|
insert
| 24 | 24 | 24 | 25 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef vector<vector<int>> Graph;
int dfs(int node, Graph &g, vector<int> &values) {
int answer = 0;
for (auto i : g[node]) {
answer = max(answer, dfs(i, g, values) + 1);
}
return values[node] = answer;
}
int main() {
int n, m, x, y;
while (cin >> n >> m) {
Graph G(n);
vector<int> in(n);
vector<int> answer(n, -1);
for (int i = 0; i < m; ++i) {
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
in[y]++;
}
for (int i = 0; i < n; ++i) {
if (in[i] == 0) {
dfs(i, G, answer);
}
}
cout << *max_element(answer.begin(), answer.end()) << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef vector<vector<int>> Graph;
int dfs(int node, Graph &g, vector<int> &values) {
int answer = 0;
if (values[node] != -1)
return values[node];
for (auto i : g[node]) {
answer = max(answer, dfs(i, g, values) + 1);
}
return values[node] = answer;
}
int main() {
int n, m, x, y;
while (cin >> n >> m) {
Graph G(n);
vector<int> in(n);
vector<int> answer(n, -1);
for (int i = 0; i < m; ++i) {
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
in[y]++;
}
for (int i = 0; i < n; ++i) {
if (in[i] == 0) {
dfs(i, G, answer);
}
}
cout << *max_element(answer.begin(), answer.end()) << endl;
}
return 0;
}
|
insert
| 9 | 9 | 9 | 11 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define N 100010
int vis[N];
int dp[N];
int dfs(int u, vector<vector<int>> &adj) {
if (!vis[u]) {
for (auto v : adj[u])
dp[u] = max(dp[u], 1 + dfs(v, adj));
}
return dp[u];
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
adj[u - 1].push_back(v - 1);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
ans = max(ans, dfs(i, adj));
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define N 100010
int vis[N];
int dp[N];
int dfs(int u, vector<vector<int>> &adj) {
if (!vis[u]) {
vis[u] = 1;
for (auto v : adj[u])
dp[u] = max(dp[u], 1 + dfs(v, adj));
}
return dp[u];
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
adj[u - 1].push_back(v - 1);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
ans = max(ans, dfs(i, adj));
}
}
cout << ans << endl;
}
|
insert
| 9 | 9 | 9 | 10 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int maxv = 5 + 5;
vector<int> arr[maxv];
vector<int> indeg(maxv);
vector<int> vis(maxv);
vector<int> dis(maxv);
void dfs(int i) {
vis[i] = 1;
for (auto v : arr[i]) {
--indeg[v];
dis[v] = max(dis[v], 1 + dis[i]);
if (indeg[v] == 0) {
dfs(v);
}
}
}
int main() {
int v, e;
cin >> v >> e;
int x, y;
for (int i = 0; i < e; i++) {
cin >> x >> y;
arr[x].push_back(y);
++indeg[y];
}
for (int i = 1; i <= v; i++) {
if (vis[i] == 0 && indeg[i] == 0) { // start with vertices with indegree 0
dfs(i);
}
}
int ans = 0;
for (auto v : dis) {
// cout<<v<<" ";
ans = max(ans, v);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int maxv = 1e5 + 5;
vector<int> arr[maxv];
vector<int> indeg(maxv);
vector<int> vis(maxv);
vector<int> dis(maxv);
void dfs(int i) {
vis[i] = 1;
for (auto v : arr[i]) {
--indeg[v];
dis[v] = max(dis[v], 1 + dis[i]);
if (indeg[v] == 0) {
dfs(v);
}
}
}
int main() {
int v, e;
cin >> v >> e;
int x, y;
for (int i = 0; i < e; i++) {
cin >> x >> y;
arr[x].push_back(y);
++indeg[y];
}
for (int i = 1; i <= v; i++) {
if (vis[i] == 0 && indeg[i] == 0) { // start with vertices with indegree 0
dfs(i);
}
}
int ans = 0;
for (auto v : dis) {
// cout<<v<<" ";
ans = max(ans, v);
}
cout << ans << "\n";
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p03166
|
C++
|
Runtime Error
|
/*
* Created by Dipta Das on 29-06-2019
* Title:
* Problem Link:
* Editorial:
* Source Code:
* Comments:
*/
#include <bits/stdc++.h>
#include <stdio.h>
#define fin freopen("input", "r", stdin)
#define whatis(x) cerr << #x << ": " << x << endl;
using namespace std;
using ll = long long;
vector<ll> adj[10005];
ll ans[100005];
ll mini;
ll dfs(ll curr) {
ll &now = ans[curr];
if (now != -1)
return now;
now = 0;
for (int i = 0; i < (int)adj[curr].size(); ++i) {
now = max(now, dfs(adj[curr][i]) + 1);
}
return now;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0, x, y; i < m; ++i) {
cin >> x >> y;
adj[x].push_back(y);
}
memset(ans, -1, sizeof(ans));
ll mn = 0;
for (int i = 1; i <= n; ++i) {
mn = max(mn, dfs(i));
}
cout << mn << endl;
return 0;
}
|
/*
* Created by Dipta Das on 29-06-2019
* Title:
* Problem Link:
* Editorial:
* Source Code:
* Comments:
*/
#include <bits/stdc++.h>
#include <stdio.h>
#define fin freopen("input", "r", stdin)
#define whatis(x) cerr << #x << ": " << x << endl;
using namespace std;
using ll = long long;
vector<ll> adj[100005];
ll ans[100005];
ll mini;
ll dfs(ll curr) {
ll &now = ans[curr];
if (now != -1)
return now;
now = 0;
for (int i = 0; i < (int)adj[curr].size(); ++i) {
now = max(now, dfs(adj[curr][i]) + 1);
}
return now;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0, x, y; i < m; ++i) {
cin >> x >> y;
adj[x].push_back(y);
}
memset(ans, -1, sizeof(ans));
ll mn = 0;
for (int i = 1; i <= n; ++i) {
mn = max(mn, dfs(i));
}
cout << mn << endl;
return 0;
}
|
replace
| 17 | 18 | 17 | 18 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <fstream>
#include <iostream>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define maxim INT_MAX
#define fi first
#define se second
#define INF 1e16
/* 1. If you can't keep solution in mind, then visualize it on a paper.
* 2. Try to identify the type of problem - DP, Greedy, Graph, Constructive,
* Prefix/Suffix, Difference Array, BIT/Segment Tree, etc.
* 3. Look at the problems from different perspectives - reverse the problem,
* add instead of delete (maybe?)
* 4. Divide difficult solutions into cases and/or sequences.
* 5. Use math rules to solve Nested Summation.
* 6. Optimisation problems are generally solved with DP, greedy, binary search
* or brute-force.
* 7. Try fixing a solution then proving we can't do better or worse than that.
* ------------------------------------------------------------------
*/
vector<ll> adj[100005];
ll dis[100005];
ll ans = 0;
ll dfs(ll node) {
for (auto child : adj[node]) {
if (dis[child] == 0)
dfs(child);
dis[node] = max(dis[node], 1 + dis[child]);
}
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> indeg(n + 1, 0);
for (ll i = 1; i <= m; i++) {
ll u, v;
cin >> u >> v;
adj[u].pb(v);
indeg[v]++;
}
vector<ll> vertices;
for (ll i = 1; i <= n; i++) {
if (indeg[i] == 0)
vertices.pb(i);
}
memset(dis, 0, sizeof(dis));
for (auto vertex : vertices) {
dis[vertex] = 0;
dfs(vertex);
}
ll ans = 0;
for (ll i = 1; i <= n; i++)
ans = max(ans, dis[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#include <fstream>
#include <iostream>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define maxim INT_MAX
#define fi first
#define se second
#define INF 1e16
/* 1. If you can't keep solution in mind, then visualize it on a paper.
* 2. Try to identify the type of problem - DP, Greedy, Graph, Constructive,
* Prefix/Suffix, Difference Array, BIT/Segment Tree, etc.
* 3. Look at the problems from different perspectives - reverse the problem,
* add instead of delete (maybe?)
* 4. Divide difficult solutions into cases and/or sequences.
* 5. Use math rules to solve Nested Summation.
* 6. Optimisation problems are generally solved with DP, greedy, binary search
* or brute-force.
* 7. Try fixing a solution then proving we can't do better or worse than that.
* ------------------------------------------------------------------
*/
vector<ll> adj[100005];
ll dis[100005];
ll ans = 0;
void dfs(ll node) {
for (auto child : adj[node]) {
if (dis[child] == 0)
dfs(child);
dis[node] = max(dis[node], 1 + dis[child]);
}
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> indeg(n + 1, 0);
for (ll i = 1; i <= m; i++) {
ll u, v;
cin >> u >> v;
adj[u].pb(v);
indeg[v]++;
}
vector<ll> vertices;
for (ll i = 1; i <= n; i++) {
if (indeg[i] == 0)
vertices.pb(i);
}
memset(dis, 0, sizeof(dis));
for (auto vertex : vertices) {
dis[vertex] = 0;
dfs(vertex);
}
ll ans = 0;
for (ll i = 1; i <= n; i++)
ans = max(ans, dis[i]);
cout << ans << endl;
}
|
replace
| 26 | 27 | 26 | 27 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int dfs(vector<vector<int>> &g, vector<bool> &visited, vector<int> &dp, int u) {
visited[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
dp[u] = max(dp[u], 1 + dfs(g, visited, dp, v));
}
return dp[u];
}
int main() {
int n, m, x, y;
cin >> n >> m;
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--, y--;
g[x].push_back(y);
}
vector<bool> isvisited(n, false);
vector<int> dp(n, 0);
for (int i = 0; i < n; i++) {
if (!isvisited[i]) {
dfs(g, isvisited, dp, i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(dp[i], ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dfs(vector<vector<int>> &g, vector<bool> &visited, vector<int> &dp, int u) {
if (visited[u])
return dp[u];
visited[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
dp[u] = max(dp[u], 1 + dfs(g, visited, dp, v));
}
return dp[u];
}
int main() {
int n, m, x, y;
cin >> n >> m;
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--, y--;
g[x].push_back(y);
}
vector<bool> isvisited(n, false);
vector<int> dp(n, 0);
for (int i = 0; i < n; i++) {
if (!isvisited[i]) {
dfs(g, isvisited, dp, i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(dp[i], ans);
}
cout << ans << endl;
return 0;
}
|
insert
| 3 | 3 | 3 | 5 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int DFS(vector<vector<int>> Graph, vector<int> DP, int node) {
if (DP[node] != 0) {
return DP[node];
}
int result = 0;
unsigned int i;
for (i = 0; i < Graph[node].size(); i++) {
result = max(result, 1 + DFS(Graph, DP, Graph[node][i]));
}
DP[node] = result;
// cout<<result<<endl;
return result;
}
int main() {
int N, M;
cin >> N >> M;
int i;
vector<vector<int>> Graph(N + 1);
vector<int> DP(N + 1, 0);
int x, y;
for (i = 0; i < M; i++) {
cin >> x >> y;
Graph[x].push_back(y);
}
int result = 0;
for (i = 1; i <= N; i++) {
result = max(result, DFS(Graph, DP, i));
}
cout << result;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int DFS(vector<vector<int>> &Graph, vector<int> &DP, int node) {
if (DP[node] != 0) {
return DP[node];
}
int result = 0;
unsigned int i;
for (i = 0; i < Graph[node].size(); i++) {
result = max(result, 1 + DFS(Graph, DP, Graph[node][i]));
}
DP[node] = result;
// cout<<result<<endl;
return result;
}
int main() {
int N, M;
cin >> N >> M;
int i;
vector<vector<int>> Graph(N + 1);
vector<int> DP(N + 1, 0);
int x, y;
for (i = 0; i < M; i++) {
cin >> x >> y;
Graph[x].push_back(y);
}
int result = 0;
for (i = 1; i <= N; i++) {
result = max(result, DFS(Graph, DP, i));
}
cout << result;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
typedef long long lint;
using namespace std;
const int MAXN = 1e5 + 1;
const int INF = 1e9 + 7;
vector<int> dp;
vector<vector<int>> adj;
vector<int> ind;
vector<int> outd;
int N, M;
int f(int s) {
int &ret = dp[s];
if (ret != -1)
return ret;
if (outd[s] == 0)
return ret = 0;
ret = 1;
for (int i : adj[s]) {
ret = max(ret, f(i) + 1);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M;
dp.resize(N + 1, -1), ind.resize(N + 1, 0), outd.resize(N + 1, 0),
adj.resize(N + 1, vector<int>(N + 1));
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
outd[u]++, ind[v]++, adj[u].push_back(v);
}
int ans = 0;
for (int i = 1; i <= N; ++i) {
if (ind[i])
continue;
ans = max(ans, f(i));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
typedef long long lint;
using namespace std;
const int MAXN = 1e5 + 1;
const int INF = 1e9 + 7;
vector<int> dp;
vector<vector<int>> adj;
vector<int> ind;
vector<int> outd;
int N, M;
int f(int s) {
int &ret = dp[s];
if (ret != -1)
return ret;
if (outd[s] == 0)
return ret = 0;
ret = 1;
for (int i : adj[s]) {
ret = max(ret, f(i) + 1);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M;
dp.resize(N + 1, -1), ind.resize(N + 1, 0), outd.resize(N + 1, 0),
adj.resize(N + 1);
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
outd[u]++, ind[v]++, adj[u].push_back(v);
}
int ans = 0;
for (int i = 1; i <= N; ++i) {
if (ind[i])
continue;
ans = max(ans, f(i));
}
cout << ans << '\n';
return 0;
}
|
replace
| 27 | 28 | 27 | 28 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define int long long
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repn(i, a, b) for (int i = a; i >= b; i--)
#define ff first
#define ss second
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define vvi vector<vector<int>>;
#define mi map<int, int>
#define mii map<pii, int>
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define sz(x) (int)x.size()
#define all(v) (v).begin(), (v).end()
#define ret(x) return cout << x, 0;
#define rety return cout << "YES", 0;
#define retn return cout << "NO", 0;
#define fl fflush(stdout)
#define hell 1000000007
#define hell2 998244353
#define pi 3.14159265358979323846
vi g[100005], vis(10005), dp(10005);
void dfs(int v, int p) {
vis[v] = 1;
for (auto u : g[v]) {
if (!vis[u])
dfs(u, v);
dp[v] = max(dp[v], dp[u] + 1);
}
}
int solve() {
int n, m, u, v;
cin >> n >> m;
rep(i, 0, m) {
cin >> u >> v;
u--;
v--;
g[u].pb(v);
}
int ans = 0;
rep(i, 0, n) {
if (!vis[i])
dfs(i, i);
ans = max(ans, dp[i]);
// cout<<dp[i]<<' ';
}
cout << ans;
return 0;
}
signed main() {
IOS;
int t = 1;
// cin>>t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define int long long
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repn(i, a, b) for (int i = a; i >= b; i--)
#define ff first
#define ss second
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define vvi vector<vector<int>>;
#define mi map<int, int>
#define mii map<pii, int>
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define sz(x) (int)x.size()
#define all(v) (v).begin(), (v).end()
#define ret(x) return cout << x, 0;
#define rety return cout << "YES", 0;
#define retn return cout << "NO", 0;
#define fl fflush(stdout)
#define hell 1000000007
#define hell2 998244353
#define pi 3.14159265358979323846
vi g[100005], vis(100005), dp(100005);
void dfs(int v, int p) {
vis[v] = 1;
for (auto u : g[v]) {
if (!vis[u])
dfs(u, v);
dp[v] = max(dp[v], dp[u] + 1);
}
}
int solve() {
int n, m, u, v;
cin >> n >> m;
rep(i, 0, m) {
cin >> u >> v;
u--;
v--;
g[u].pb(v);
}
int ans = 0;
rep(i, 0, n) {
if (!vis[i])
dfs(i, i);
ans = max(ans, dp[i]);
// cout<<dp[i]<<' ';
}
cout << ans;
return 0;
}
signed main() {
IOS;
int t = 1;
// cin>>t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
replace
| 33 | 34 | 33 | 34 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <deque>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
bool check_flg(vector<bool> &flag, vector<pair<vector<int>, vector<int>>> &na,
int i) {
for (int j = 0; j < na[i].second.size(); j++) {
if (flag[na[i].second[j]] == false)
return false;
}
return true;
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<vector<int>, vector<int>>> na(N);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
na[a - 1].first.push_back(b - 1);
na[b - 1].second.push_back(a - 1);
}
vector<int> n;
// topological sort
vector<bool> flag(N, false);
deque<int> dp;
for (int i = 0; i < N; i++) {
if (na[i].second.size() == 0) {
n.push_back(i);
dp.push_back(i);
flag[i] = true;
}
}
while (dp.size() > 0) {
int nn = dp.back();
dp.pop_back();
if (check_flg(flag, na, nn) == false)
continue;
if (flag[nn] == false) {
n.push_back(nn);
flag[nn] = true;
}
for (int i = 0; i < na[nn].first.size(); i++) {
dp.push_back(na[nn].first[i]);
}
}
// for(auto x: n) cout << x << " ";
// cout << endl;
vector<int> dd(N, 0);
int out = 0;
for (int i = 1; i < N; i++) {
int nm = 0;
for (int j = 0; j < na[n[i]].second.size(); j++) {
nm = max(nm, dd[na[n[i]].second[j]] + 1);
// cout << na[n[i]].second[j] << "->" << n[i] << " " << nm
//<< endl;
}
dd[n[i]] = nm;
out = max(out, dd[n[i]]);
}
cout << out << endl;
return 0;
}
|
#include <algorithm>
#include <deque>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
bool check_flg(vector<bool> &flag, vector<pair<vector<int>, vector<int>>> &na,
int i) {
for (int j = 0; j < na[i].second.size(); j++) {
if (flag[na[i].second[j]] == false)
return false;
}
return true;
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<vector<int>, vector<int>>> na(N);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
na[a - 1].first.push_back(b - 1);
na[b - 1].second.push_back(a - 1);
}
vector<int> n;
// topological sort
vector<bool> flag(N, false);
deque<int> dp;
for (int i = 0; i < N; i++) {
if (na[i].second.size() == 0) {
n.push_back(i);
dp.push_back(i);
flag[i] = true;
}
}
while (dp.size() > 0) {
int nn = dp.back();
dp.pop_back();
if (check_flg(flag, na, nn) == false)
continue;
if (flag[nn] == false) {
n.push_back(nn);
flag[nn] = true;
}
for (int i = 0; i < na[nn].first.size(); i++) {
if (flag[na[nn].first[i]] == false)
dp.push_back(na[nn].first[i]);
}
}
// for(auto x: n) cout << x << " ";
// cout << endl;
vector<int> dd(N, 0);
int out = 0;
for (int i = 1; i < N; i++) {
int nm = 0;
for (int j = 0; j < na[n[i]].second.size(); j++) {
nm = max(nm, dd[na[n[i]].second[j]] + 1);
// cout << na[n[i]].second[j] << "->" << n[i] << " " << nm
//<< endl;
}
dd[n[i]] = nm;
out = max(out, dd[n[i]]);
}
cout << out << endl;
return 0;
}
|
replace
| 51 | 52 | 51 | 53 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const ll LINF = 1LL << 50;
// const int MAX = 1e+5;
const int MAX = 6;
const int NIL = -1;
/* global variables */
int N, M;
vector<vector<int>> G(MAX, vector<int>());
vector<int> indeg(MAX, 0);
vector<int> dist(MAX, NIL);
/* function */
void input() {
for (int i = 0; i < M; i++) {
int s, t;
cin >> s >> t;
s--, t--;
G[s].push_back(t);
indeg[t]++;
}
}
void bfs(int st) {
queue<int> q;
q.push(st);
dist[st] = 0;
while (q.size()) {
int from = q.front();
q.pop();
for (int to : G[from]) {
indeg[to]--;
dist[to] = max(dist[to], dist[from] + 1);
if (indeg[to] == 0) {
q.push(to);
}
}
}
}
void topologicalSort() {
for (int i = 0; i < N; i++)
if (indeg[i] == 0 && dist[i] == NIL)
bfs(i);
}
void printAns() { cout << *max_element(dist.begin(), dist.end()) << '\n'; }
/* main */
int main() {
cin >> N >> M;
input();
topologicalSort();
printAns();
}
|
#include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const ll LINF = 1LL << 50;
const int MAX = 1e+5;
const int NIL = -1;
/* global variables */
int N, M;
vector<vector<int>> G(MAX, vector<int>());
vector<int> indeg(MAX, 0);
vector<int> dist(MAX, NIL);
/* function */
void input() {
for (int i = 0; i < M; i++) {
int s, t;
cin >> s >> t;
s--, t--;
G[s].push_back(t);
indeg[t]++;
}
}
void bfs(int st) {
queue<int> q;
q.push(st);
dist[st] = 0;
while (q.size()) {
int from = q.front();
q.pop();
for (int to : G[from]) {
indeg[to]--;
dist[to] = max(dist[to], dist[from] + 1);
if (indeg[to] == 0) {
q.push(to);
}
}
}
}
void topologicalSort() {
for (int i = 0; i < N; i++)
if (indeg[i] == 0 && dist[i] == NIL)
bfs(i);
}
void printAns() { cout << *max_element(dist.begin(), dist.end()) << '\n'; }
/* main */
int main() {
cin >> N >> M;
input();
topologicalSort();
printAns();
}
|
replace
| 7 | 9 | 7 | 8 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
using i64 = int64_t;
using P = pair<i64, i64>;
// i64 mod = 1000000007;
// int int_max = 2147483647;
i64 INF = 1e12;
int max_n = 1e5;
struct edge {
edge() : link_to(0), cost(0) {}
edge(int t, int c) : link_to(t), cost(c) {}
int link_to;
int cost;
};
vector<int> memo(100010, -1);
int rec(vector<vector<edge>> &graph, int v) {
if (memo[v] != -1)
return memo[v];
int ret{0};
for (auto e : graph[v]) {
ret = max(ret, rec(graph, e.link_to) + e.cost);
}
return ret;
}
int main(int argc, char **argv) {
i64 n, m;
cin >> n >> m;
vector<vector<edge>> graph(n);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
graph[x].push_back(edge(y, 1));
}
int ans{0};
for (int i = 0; i < n; ++i) {
ans = max(ans, rec(graph, i));
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
using i64 = int64_t;
using P = pair<i64, i64>;
// i64 mod = 1000000007;
// int int_max = 2147483647;
i64 INF = 1e12;
int max_n = 1e5;
struct edge {
edge() : link_to(0), cost(0) {}
edge(int t, int c) : link_to(t), cost(c) {}
int link_to;
int cost;
};
vector<int> memo(100010, -1);
int rec(vector<vector<edge>> &graph, int v) {
if (memo[v] != -1)
return memo[v];
int ret{0};
for (auto e : graph[v]) {
ret = max(ret, rec(graph, e.link_to) + e.cost);
}
return memo[v] = ret;
}
int main(int argc, char **argv) {
i64 n, m;
cin >> n >> m;
vector<vector<edge>> graph(n);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
graph[x].push_back(edge(y, 1));
}
int ans{0};
for (int i = 0; i < n; ++i) {
ans = max(ans, rec(graph, i));
}
cout << ans << endl;
return 0;
}
|
replace
| 40 | 41 | 40 | 41 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__() \
for (long blockTime = NULL; \
(blockTime == NULL ? (blockTime = clock()) != NULL : false); \
debug("Time:%.4fs\n", (double)(clock() - blockTime) / CLOCKS_PER_SEC))
#define setp(x) cout << fixed << setprecision(x)
#define forn(i, a, b) for (int i = a; i < b; i++)
#define fore(i, a, b) for (int i = a; i <= b; i++)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define PI 3.14159265358979323846264338327
#define INF 1000000000
#define MOD 998244353
#define MAXN 111111
typedef long long ll;
typedef pair<ll, ll> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef unsigned long long ull;
int n, m, ans = 0;
int memo[MAXN];
vi adj[MAXN];
int dp(int v) {
if (memo[v] != -1)
return memo[v];
int tmp = 0;
for (auto i : adj[v])
tmp = max(tmp, dp(i) + 1);
return tmp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
fore(i, 1, n) memo[i] = -1;
forn(i, 0, m) {
int x, y;
cin >> x >> y;
adj[y].pb(x);
}
fore(i, 1, n) { ans = max(ans, dp(i)); }
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__() \
for (long blockTime = NULL; \
(blockTime == NULL ? (blockTime = clock()) != NULL : false); \
debug("Time:%.4fs\n", (double)(clock() - blockTime) / CLOCKS_PER_SEC))
#define setp(x) cout << fixed << setprecision(x)
#define forn(i, a, b) for (int i = a; i < b; i++)
#define fore(i, a, b) for (int i = a; i <= b; i++)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define PI 3.14159265358979323846264338327
#define INF 1000000000
#define MOD 998244353
#define MAXN 111111
typedef long long ll;
typedef pair<ll, ll> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef unsigned long long ull;
int n, m, ans = 0;
int memo[MAXN];
vi adj[MAXN];
int dp(int v) {
if (memo[v] != -1)
return memo[v];
int tmp = 0;
for (auto i : adj[v])
tmp = max(tmp, dp(i) + 1);
memo[v] = tmp;
return tmp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
fore(i, 1, n) memo[i] = -1;
forn(i, 0, m) {
int x, y;
cin >> x >> y;
adj[y].pb(x);
}
fore(i, 1, n) { ans = max(ans, dp(i)); }
cout << ans;
return 0;
}
|
insert
| 35 | 35 | 35 | 36 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repo(i, n) for (int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL << 61;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P) {
if (P == 0)
return 1;
if (P % 2 == 0) {
ll t = jou(N, P / 2);
return t * t % mod;
}
return (N * jou(N, P - 1)) % mod;
} // jou(n,mod-2)で逆元
// intの最大値2147483647 ≒ 2×10^9
// long longの最大値9223372036854775807 ≒ 9×10^18
//'大文字'+=32; で小文字に
// cout << fixed << setprecision (20); 小数点以下2０桁まで
// 実行時間制約2秒では２×10^8回くらいまで計算できる
int len(int x, vector<vector<int>> &p, vector<int> &memo) {
if (memo[x] != -1)
return memo[x];
if (p[x].empty())
return 0;
int rtn = 0;
for (auto z : p[x]) {
chmax(rtn, len(z, p, memo) + 1);
}
return rtn;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> p(n);
rep(i, m) {
int x, y;
cin >> x >> y;
x--;
y--;
p[x].pb(y);
}
vector<int> memo(n, -1);
int ans = 0;
rep(i, n) { chmax(ans, len(i, p, memo)); }
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repo(i, n) for (int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL << 61;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P) {
if (P == 0)
return 1;
if (P % 2 == 0) {
ll t = jou(N, P / 2);
return t * t % mod;
}
return (N * jou(N, P - 1)) % mod;
} // jou(n,mod-2)で逆元
// intの最大値2147483647 ≒ 2×10^9
// long longの最大値9223372036854775807 ≒ 9×10^18
//'大文字'+=32; で小文字に
// cout << fixed << setprecision (20); 小数点以下2０桁まで
// 実行時間制約2秒では２×10^8回くらいまで計算できる
int len(int x, vector<vector<int>> &p, vector<int> &memo) {
if (memo[x] != -1)
return memo[x];
if (p[x].empty())
return 0;
int rtn = 0;
for (auto z : p[x]) {
chmax(rtn, len(z, p, memo) + 1);
}
memo[x] = rtn;
return rtn;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> p(n);
rep(i, m) {
int x, y;
cin >> x >> y;
x--;
y--;
p[x].pb(y);
}
vector<int> memo(n, -1);
int ans = 0;
rep(i, n) { chmax(ans, len(i, p, memo)); }
cout << ans << endl;
}
|
insert
| 57 | 57 | 57 | 58 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
/*
$$$$$$$\ $$\ $$$$$$$\
$$ __$$\ \__| $$ __$$\
$$ | $$ | $$$$$$\ $$$$$$\ $$\ $$$$$$$\ $$ | $$ | $$$$$$\ $$$$$$\
$$$$$$$\ $$$$$$\
$$$$$$$\ |$$ __$$\ $$ __$$\ $$ |$$ _____|$$$$$$$\ | \____$$\ $$
__$$\ $$ _____|\____$$\
$$ __$$\ $$ / $$ |$$ | \__|$$ |\$$$$$$\ $$ __$$\ $$$$$$$ |$$ |
\__|$$ / $$$$$$$ |
$$ | $$ |$$ | $$ |$$ | $$ | \____$$\ $$ | $$ |$$ __$$ |$$ | $$
| $$ __$$ |
$$$$$$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |$$$$$$$ |\$$$$$$$ |$$ |
\$$$$$$$\\$$$$$$$ |
\_______/ \______/ \__| \__|\_______/ \_______/ \_______|\__|
\_______|\_______|
*/
#include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define MP make_pair
#define INS insert
#define LB lower_bound
#define UB upper_bound
#define pii pair<int, int>
#define pll pair<long long, long long>
#define si pair<string, int>
#define is pair<int, string>
#define X first
#define Y second
#define _ << " " <<
#define sz(x) (int)x.size()
#define all(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORD(i, a, b) for (int i = (a); i > (b); --i)
#define FORR(i, l, r) for (int i = (l); i <= (r); ++i)
#define FORP(i, a, b) for ((i) = (a); (i) < (b); ++i)
#define FORA(i, x) for (auto &i : x)
#define REP(i, n) FOR(i, 0, n)
#define BITS(x) __builtin_popcount(x)
#define MSET memset
#define MCPY memcpy
#define SQ(a) (a) * (a)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<ll> vll;
typedef vector<pll> vpl;
typedef vector<double> vd;
typedef vector<ld> vld;
typedef vector<si> vsi;
typedef vector<is> vis;
typedef vector<string> vs;
//((float) t)/CLOCKS_PER_SEC
const int MOD = 1e9 + 7;
const int PI = acos(-1);
const int LOG = 20;
const int INF = 1e9 + 10;
const ll INFL = 1e18 + 10;
const int ABC = 30;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const int dox[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int doy[] = {0, 0, -1, 1, -1, 1, -1, 1};
inline int sum(int a, int b) {
if (a + b >= MOD)
return a + b - MOD;
if (a + b < 0)
return a + b + MOD;
return a + b;
}
inline void add(int &a, int b) { a = sum(a, b); }
inline int pot(ll pot, int n) {
ll ret = 1;
while (n) {
if (n & 1)
ret = (ret * pot) % MOD;
pot = (pot * pot) % MOD;
n >>= 1;
}
return ret;
}
inline int mul(int a, int b) { return (ll)a * (ll)b % MOD; }
inline int sub(int a, int b) { return (a - b + MOD) % MOD; }
inline int divide(int a, int b) { return mul(a, pot(b, MOD - 2)); }
ll lcm(ll a, ll b) { return abs(a * b) / __gcd(a, b); }
inline double ccw(pii A, pii B, pii C) {
return (A.X * B.Y) - (A.Y * B.X) + (B.X * C.Y) - (B.Y * C.X) + (C.X * A.Y) -
(C.Y * A.X);
}
inline int CCW(pii A, pii B, pii C) {
double val = ccw(A, B, C);
double eps = max(max(abs(A.X), abs(A.Y)),
max(max(abs(B.X), abs(B.Y)), max(abs(C.X), abs(C.Y)))) /
1e9;
if (val <= -eps)
return -1;
if (val >= eps)
return 1;
return 0;
}
void to_upper(string &x) {
REP(i, sz(x))
x[i] = toupper(x[i]);
}
void to_lower(string &x) {
REP(i, sz(x))
x[i] = tolower(x[i]);
}
string its(ll x) {
if (x == 0)
return "0";
string ret = "";
while (x > 0) {
ret += (x % 10) + '0';
x /= 10;
}
reverse(all(ret));
return ret;
}
ll sti(string s) {
ll ret = 0;
REP(i, sz(s)) {
ret *= 10;
ret += (s[i] - '0');
}
return ret;
}
const int N = 1e5 + 10;
const int OFF = (1 << LOG);
int n, m, memo[N];
vi e[N];
queue<int> start;
bool bio[N];
void dfs(int node) {
bio[node]++;
FORA(x, e[node])
dfs(x);
}
void findComponents() {
REP(i, n) {
if (!bio[i + 1]) {
start.push(i + 1);
dfs(i + 1);
}
}
}
int dp(int node) {
int &ret = memo[node];
if (~ret)
return ret;
// cout << node << '\n';
ret = 0;
FORA(nxt, e[node])
ret = max(ret, dp(nxt) + 1);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
REP(i, m) {
int x, y;
cin >> x >> y;
e[x].PB(y);
}
MSET(memo, -1, sizeof memo);
findComponents();
int sol = 0;
for (; !start.empty(); start.pop()) {
// cout << start.front() << '\n';
if (dp(start.front()) > sol)
sol = dp(start.front());
}
cout << sol << '\n';
return 0;
}
|
/*
$$$$$$$\ $$\ $$$$$$$\
$$ __$$\ \__| $$ __$$\
$$ | $$ | $$$$$$\ $$$$$$\ $$\ $$$$$$$\ $$ | $$ | $$$$$$\ $$$$$$\
$$$$$$$\ $$$$$$\
$$$$$$$\ |$$ __$$\ $$ __$$\ $$ |$$ _____|$$$$$$$\ | \____$$\ $$
__$$\ $$ _____|\____$$\
$$ __$$\ $$ / $$ |$$ | \__|$$ |\$$$$$$\ $$ __$$\ $$$$$$$ |$$ |
\__|$$ / $$$$$$$ |
$$ | $$ |$$ | $$ |$$ | $$ | \____$$\ $$ | $$ |$$ __$$ |$$ | $$
| $$ __$$ |
$$$$$$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |$$$$$$$ |\$$$$$$$ |$$ |
\$$$$$$$\\$$$$$$$ |
\_______/ \______/ \__| \__|\_______/ \_______/ \_______|\__|
\_______|\_______|
*/
#include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define MP make_pair
#define INS insert
#define LB lower_bound
#define UB upper_bound
#define pii pair<int, int>
#define pll pair<long long, long long>
#define si pair<string, int>
#define is pair<int, string>
#define X first
#define Y second
#define _ << " " <<
#define sz(x) (int)x.size()
#define all(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORD(i, a, b) for (int i = (a); i > (b); --i)
#define FORR(i, l, r) for (int i = (l); i <= (r); ++i)
#define FORP(i, a, b) for ((i) = (a); (i) < (b); ++i)
#define FORA(i, x) for (auto &i : x)
#define REP(i, n) FOR(i, 0, n)
#define BITS(x) __builtin_popcount(x)
#define MSET memset
#define MCPY memcpy
#define SQ(a) (a) * (a)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<ll> vll;
typedef vector<pll> vpl;
typedef vector<double> vd;
typedef vector<ld> vld;
typedef vector<si> vsi;
typedef vector<is> vis;
typedef vector<string> vs;
//((float) t)/CLOCKS_PER_SEC
const int MOD = 1e9 + 7;
const int PI = acos(-1);
const int LOG = 20;
const int INF = 1e9 + 10;
const ll INFL = 1e18 + 10;
const int ABC = 30;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const int dox[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int doy[] = {0, 0, -1, 1, -1, 1, -1, 1};
inline int sum(int a, int b) {
if (a + b >= MOD)
return a + b - MOD;
if (a + b < 0)
return a + b + MOD;
return a + b;
}
inline void add(int &a, int b) { a = sum(a, b); }
inline int pot(ll pot, int n) {
ll ret = 1;
while (n) {
if (n & 1)
ret = (ret * pot) % MOD;
pot = (pot * pot) % MOD;
n >>= 1;
}
return ret;
}
inline int mul(int a, int b) { return (ll)a * (ll)b % MOD; }
inline int sub(int a, int b) { return (a - b + MOD) % MOD; }
inline int divide(int a, int b) { return mul(a, pot(b, MOD - 2)); }
ll lcm(ll a, ll b) { return abs(a * b) / __gcd(a, b); }
inline double ccw(pii A, pii B, pii C) {
return (A.X * B.Y) - (A.Y * B.X) + (B.X * C.Y) - (B.Y * C.X) + (C.X * A.Y) -
(C.Y * A.X);
}
inline int CCW(pii A, pii B, pii C) {
double val = ccw(A, B, C);
double eps = max(max(abs(A.X), abs(A.Y)),
max(max(abs(B.X), abs(B.Y)), max(abs(C.X), abs(C.Y)))) /
1e9;
if (val <= -eps)
return -1;
if (val >= eps)
return 1;
return 0;
}
void to_upper(string &x) {
REP(i, sz(x))
x[i] = toupper(x[i]);
}
void to_lower(string &x) {
REP(i, sz(x))
x[i] = tolower(x[i]);
}
string its(ll x) {
if (x == 0)
return "0";
string ret = "";
while (x > 0) {
ret += (x % 10) + '0';
x /= 10;
}
reverse(all(ret));
return ret;
}
ll sti(string s) {
ll ret = 0;
REP(i, sz(s)) {
ret *= 10;
ret += (s[i] - '0');
}
return ret;
}
const int N = 1e5 + 10;
const int OFF = (1 << LOG);
int n, m, memo[N];
vi e[N];
queue<int> start;
bool bio[N];
void dfs(int node) {
bio[node]++;
FORA(x, e[node])
if (!bio[node])
dfs(x);
}
void findComponents() {
REP(i, n) {
if (!bio[i + 1]) {
start.push(i + 1);
dfs(i + 1);
}
}
}
int dp(int node) {
int &ret = memo[node];
if (~ret)
return ret;
// cout << node << '\n';
ret = 0;
FORA(nxt, e[node])
ret = max(ret, dp(nxt) + 1);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
REP(i, m) {
int x, y;
cin >> x >> y;
e[x].PB(y);
}
MSET(memo, -1, sizeof memo);
findComponents();
int sol = 0;
for (; !start.empty(); start.pop()) {
// cout << start.front() << '\n';
if (dp(start.front()) > sol)
sol = dp(start.front());
}
cout << sol << '\n';
return 0;
}
|
replace
| 157 | 158 | 157 | 159 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
// clang-format off
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#ifndef godfather
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#endif
// #define int long long
typedef long long ll;
typedef long double ld;
typedef long double f80;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef gp_hash_table<int, int> umap;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update> oset;
typedef pair<pii, int> piii;
typedef vector<int> vi;
typedef vector<pii> vii;
#define INF 100000000000000000
#define inf 1000000000
#define MOD 1000000007
#define PI 3.1415926535897932385
#define pb push_back
#define bitc __builtin_popcountll
#define mp make_pair
#define all(ar) ar.begin(), ar.end()
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define rep(i, n) for (int i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define foreach(it, ar) for (auto it = ar.begin(); it != ar.end(); it++)
#define fil(ar, val) memset(ar, val, sizeof(ar)) // 0x3f for inf, 0x80 for -INF can also use with pairs
#ifdef godfather
template<typename T>
void __p(T a) { cout << a << " "; }
template<typename T>
void __p(std::vector<T> a) { cout << "{ "; for (auto p : a) __p(p); cout << "}"; }
template<typename T, typename F>
void __p(pair<T, F> a) { cout << "{ "; __p(a.first); __p(a.second); cout << "}"; }
template<typename T, typename ...Arg>
void __p(T a1, Arg ...a) { __p(a1); __p(a...); }
template<typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cout<<name<<" : ";__p(arg1);cout<<endl;
}
template<typename Arg1, typename ... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args) {
int bracket=0,i=0;
for(; ;i++)
if(names[i]==','&&bracket==0)
break;
else if(names[i]=='(')
bracket++;
else if(names[i]==')')
bracket--;
const char *comma=names+i;
cout.write(names,comma-names)<<" : ";
__p(arg1);
cout<<"| ";
__f(comma+1,args...);
}
#define trace(...) cout<<"Line:"<<__LINE__<<" "; __f(#__VA_ARGS__, __VA_ARGS__)
int begtime = clock();
#define end_routine() cout << "\n\nTime elapsed: " << (clock() - begtime)*1000/CLOCKS_PER_SEC << " ms\n\n";
#else
#define trace(...)
#define end_routine()
#endif
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
#define rand(l, r) uniform_int_distribution<int>(l, r)(rng32)
inline bool equals(double a, double b) { return fabs(a - b) < 1e-9; }
ll modpow(ll b, ll e, ll mod=MOD) {
ll ans=1; for(;e;b=b*b%mod,e/=2) if(e&1) ans=ans*b%mod; return ans; }
ld modp(ld b, ll e) {
ld ans=1; for(;e;b=b*b,e/=2) if(e&1) ans=ans*b; return ans; }
vector<vector<int>> vec;
vector<bool>visited;int ans;
vector<int>dp;
int dfs(int v,int len){
int ret=len;
for(auto i:vec[v]){
dp[i]=dfs(i,1);
ret=max(ret,len+dp[i]);
}
return ret;
}
void solve()
{
// START
int n,m;
cin>>n>>m;
vec.resize(n);
dp.resize(n,-1);
rep(i,m){
int x,y;
cin>>x>>y;
vec[x-1].push_back(y-1);
}
ans=0;
rep(i,n){
int len=1;
if(dp[i]==-1)
dp[i]=dfs(i,len);
}
for(auto i:dp)
ans=max(ans, i);
cout<<ans-1<<endl;
// END
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15); cout<<fixed;
#ifdef godfather
cin.exceptions(cin.failbit);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t=1;
// cin>>t;
fr(i,1,t)
{
solve();
}
end_routine();
}
|
// clang-format off
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#ifndef godfather
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#endif
// #define int long long
typedef long long ll;
typedef long double ld;
typedef long double f80;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef gp_hash_table<int, int> umap;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update> oset;
typedef pair<pii, int> piii;
typedef vector<int> vi;
typedef vector<pii> vii;
#define INF 100000000000000000
#define inf 1000000000
#define MOD 1000000007
#define PI 3.1415926535897932385
#define pb push_back
#define bitc __builtin_popcountll
#define mp make_pair
#define all(ar) ar.begin(), ar.end()
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define rep(i, n) for (int i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define foreach(it, ar) for (auto it = ar.begin(); it != ar.end(); it++)
#define fil(ar, val) memset(ar, val, sizeof(ar)) // 0x3f for inf, 0x80 for -INF can also use with pairs
#ifdef godfather
template<typename T>
void __p(T a) { cout << a << " "; }
template<typename T>
void __p(std::vector<T> a) { cout << "{ "; for (auto p : a) __p(p); cout << "}"; }
template<typename T, typename F>
void __p(pair<T, F> a) { cout << "{ "; __p(a.first); __p(a.second); cout << "}"; }
template<typename T, typename ...Arg>
void __p(T a1, Arg ...a) { __p(a1); __p(a...); }
template<typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cout<<name<<" : ";__p(arg1);cout<<endl;
}
template<typename Arg1, typename ... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args) {
int bracket=0,i=0;
for(; ;i++)
if(names[i]==','&&bracket==0)
break;
else if(names[i]=='(')
bracket++;
else if(names[i]==')')
bracket--;
const char *comma=names+i;
cout.write(names,comma-names)<<" : ";
__p(arg1);
cout<<"| ";
__f(comma+1,args...);
}
#define trace(...) cout<<"Line:"<<__LINE__<<" "; __f(#__VA_ARGS__, __VA_ARGS__)
int begtime = clock();
#define end_routine() cout << "\n\nTime elapsed: " << (clock() - begtime)*1000/CLOCKS_PER_SEC << " ms\n\n";
#else
#define trace(...)
#define end_routine()
#endif
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
#define rand(l, r) uniform_int_distribution<int>(l, r)(rng32)
inline bool equals(double a, double b) { return fabs(a - b) < 1e-9; }
ll modpow(ll b, ll e, ll mod=MOD) {
ll ans=1; for(;e;b=b*b%mod,e/=2) if(e&1) ans=ans*b%mod; return ans; }
ld modp(ld b, ll e) {
ld ans=1; for(;e;b=b*b,e/=2) if(e&1) ans=ans*b; return ans; }
vector<vector<int>> vec;
vector<bool>visited;int ans;
vector<int>dp;
int dfs(int v,int len){
if(dp[v]!=-1)
return dp[v];
int ret=len;
for(auto i:vec[v]){
dp[i]=dfs(i,1);
ret=max(ret,len+dp[i]);
}
return ret;
}
void solve()
{
// START
int n,m;
cin>>n>>m;
vec.resize(n);
dp.resize(n,-1);
rep(i,m){
int x,y;
cin>>x>>y;
vec[x-1].push_back(y-1);
}
ans=0;
rep(i,n){
int len=1;
if(dp[i]==-1)
dp[i]=dfs(i,len);
}
for(auto i:dp)
ans=max(ans, i);
cout<<ans-1<<endl;
// END
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15); cout<<fixed;
#ifdef godfather
cin.exceptions(cin.failbit);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t=1;
// cin>>t;
fr(i,1,t)
{
solve();
}
end_routine();
}
|
insert
| 92 | 92 | 92 | 94 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
// #pragma GCC optimize "trapv"
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int M = 1000000007;
#define pb push_back
#define fs first
#define sc second
#define forn(i, k, n) for (int i = k; i < n; ++i)
#define nfor(i, n, k) for (int i = n; i >= k; --i)
#define vi vector<int>
#define vvi vector<vector<int>>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define vvpii vector<vector<pait<int, int>>>
#define all(arr) arr.begin(), arr.end()
#define endl '\n'
#define dbgarr(V, n) \
forn(i, 0, n) cout << V[i] << " "; \
cout << endl;
#define dbgarrrev(V, n) \
nfor(i, n, 0) cout << V[i] << " "; \
cout << endl;
#define dbgmaze(V) \
for (auto x : V) { \
for (auto y : x) \
cout << y << " "; \
cout << endl; \
}
#define dbg2d(V, n, m) \
forn(i, 0, n) { \
forn(j, 0, m) cout << V[i][j] << " "; \
cout << endl; \
}
#define N 1005
vi G[N];
bool vis[N] = {false};
int dp[N] = {0};
int ans = -1;
void dfs(int src) {
vis[src] = true;
for (auto x : G[src]) {
if (!vis[x])
dfs(x);
dp[src] = max(dp[src], 1 + dp[x]);
}
ans = max(ans, dp[src]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
forn(i, 0, m) {
int u, v;
cin >> u >> v;
G[u].pb(v);
}
forn(i, 1, n + 1) if (!vis[i]) dfs(i);
cout << ans << endl;
return 0;
}
|
// #pragma GCC optimize "trapv"
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int M = 1000000007;
#define pb push_back
#define fs first
#define sc second
#define forn(i, k, n) for (int i = k; i < n; ++i)
#define nfor(i, n, k) for (int i = n; i >= k; --i)
#define vi vector<int>
#define vvi vector<vector<int>>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define vvpii vector<vector<pait<int, int>>>
#define all(arr) arr.begin(), arr.end()
#define endl '\n'
#define dbgarr(V, n) \
forn(i, 0, n) cout << V[i] << " "; \
cout << endl;
#define dbgarrrev(V, n) \
nfor(i, n, 0) cout << V[i] << " "; \
cout << endl;
#define dbgmaze(V) \
for (auto x : V) { \
for (auto y : x) \
cout << y << " "; \
cout << endl; \
}
#define dbg2d(V, n, m) \
forn(i, 0, n) { \
forn(j, 0, m) cout << V[i][j] << " "; \
cout << endl; \
}
#define N 100005
vi G[N];
bool vis[N] = {false};
int dp[N] = {0};
int ans = -1;
void dfs(int src) {
vis[src] = true;
for (auto x : G[src]) {
if (!vis[x])
dfs(x);
dp[src] = max(dp[src], 1 + dp[x]);
}
ans = max(ans, dp[src]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
forn(i, 0, m) {
int u, v;
cin >> u >> v;
G[u].pb(v);
}
forn(i, 1, n + 1) if (!vis[i]) dfs(i);
cout << ans << endl;
return 0;
}
|
replace
| 35 | 36 | 35 | 36 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
vector<vector<int>> G;
ll n, m, ans = 0;
ll dp[100100];
ll f(int v) {
if (dp[v] != -1)
return dp[v];
ll res = 0;
for (auto g : G[v])
res = max(res, f(g) + 1);
return res;
}
int main() {
cin >> n >> m;
G.resize(n);
rep(i, m) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
}
rep(i, n) dp[i] = -1;
rep(i, n) ans = max(ans, f(i));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
vector<vector<int>> G;
ll n, m, ans = 0;
ll dp[100100];
ll f(int v) {
if (dp[v] != -1)
return dp[v];
ll res = 0;
for (auto g : G[v])
res = max(res, f(g) + 1);
return dp[v] = res;
}
int main() {
cin >> n >> m;
G.resize(n);
rep(i, m) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
}
rep(i, n) dp[i] = -1;
rep(i, n) ans = max(ans, f(i));
cout << ans << endl;
return 0;
}
|
replace
| 18 | 19 | 18 | 19 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define Phuong // <3
typedef pair<int, int> ii;
const int inf = 1e9 + 1;
int n, m;
vector<int> d, deg;
vector<vector<int>> g;
void DFS(int x) {
stack<int> st;
st.push(x);
while (!st.empty()) {
int u = st.top();
st.pop();
for (auto x : g[u]) {
d[x] = max(d[x], d[u] + 1);
st.push(x);
}
}
}
int main() {
#ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
#endif // ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
g = vector<vector<int>>(n);
deg = vector<int>(n, 0);
d = vector<int>(n, 0);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
deg[v]++;
}
for (int i = 0; i < n; ++i)
if (deg[i] == 0) {
DFS(i);
}
int ans = 0;
for (auto x : d)
ans = max(ans, x);
cout << ans;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define Phuong // <3
typedef pair<int, int> ii;
const int inf = 1e9 + 1;
int n, m;
vector<int> d, deg;
vector<vector<int>> g;
void DFS(int x) {
stack<int> st;
st.push(x);
while (!st.empty()) {
int u = st.top();
st.pop();
for (auto x : g[u])
if (deg[x] == 1) {
d[x] = max(d[x], d[u] + 1);
st.push(x);
} else {
deg[x]--;
d[x] = max(d[x], d[u] + 1);
}
}
}
int main() {
#ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
#endif // ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
g = vector<vector<int>>(n);
deg = vector<int>(n, 0);
d = vector<int>(n, 0);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
deg[v]++;
}
for (int i = 0; i < n; ++i)
if (deg[i] == 0) {
DFS(i);
}
int ans = 0;
for (auto x : d)
ans = max(ans, x);
cout << ans;
return (0);
}
|
replace
| 19 | 23 | 19 | 27 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#define loop(n) for (ll i = 0; i < n; i++)
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
typedef long long int ll;
unordered_map<ll, vector<ll>> graph;
ll dp[100001];
ll dfs(ll node, ll level) {
if (dp[node] != -1)
return level + dp[node];
ll ans = level;
auto itr = graph.find(node);
if (itr == graph.end())
return ans;
else {
vector<ll> nbs = graph[node];
for (ll i = 0; i < (ll)nbs.size(); i++) {
ans = max(ans, dfs(nbs[i], level + 1));
}
}
if (level == 0)
dp[node] = ans;
return ans;
}
int main() {
fastio;
ll n, m;
cin >> n >> m;
for (ll i = 1; i <= n; i++)
dp[i] = -1;
for (ll i = 0; i < m; i++) {
ll x, y;
cin >> x >> y;
auto itr = graph.find(x);
if (itr == graph.end()) {
vector<ll> hold;
hold.push_back(y);
graph.insert({x, hold});
} else {
graph[x].push_back(y);
}
}
ll ans = INT_MIN;
for (ll i = 1; i <= n; i++) {
ans = max(ans, dfs(i, 0));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#define loop(n) for (ll i = 0; i < n; i++)
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
typedef long long int ll;
unordered_map<ll, vector<ll>> graph;
ll dp[100001];
ll dfs(ll node, ll level) {
if (dp[node] != -1)
return level + dp[node];
ll ans = level;
auto itr = graph.find(node);
if (itr == graph.end())
return ans;
else {
vector<ll> nbs = graph[node];
for (ll i = 0; i < (ll)nbs.size(); i++) {
ans = max(ans, dfs(nbs[i], level + 1));
}
}
dp[node] = ans - level;
return ans;
}
int main() {
fastio;
ll n, m;
cin >> n >> m;
for (ll i = 1; i <= n; i++)
dp[i] = -1;
for (ll i = 0; i < m; i++) {
ll x, y;
cin >> x >> y;
auto itr = graph.find(x);
if (itr == graph.end()) {
vector<ll> hold;
hold.push_back(y);
graph.insert({x, hold});
} else {
graph[x].push_back(y);
}
}
ll ans = INT_MIN;
for (ll i = 1; i <= n; i++) {
ans = max(ans, dfs(i, 0));
}
cout << ans << endl;
return 0;
}
|
replace
| 30 | 32 | 30 | 31 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define watch(x) cout << (#x) << " is " << (x) << endl
#define f(t) for (ll i = 0; i < t; i++)
#define bs(a, x) binary_search(a.begin(), a.end(), x)
#define ll long long int
#define ul unsigned long int
#define ld long double
#define umpi unordered_map<int, int>
#define umpl unordered_map<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define fill(a, p) memset(a, p, sizeof(a))
#define pb push_back
#define mod 1000000007
#define N 100005
#define all(a) a.begin(), a.end()
#define point pair<ll, ll>
#define endl "\n"
const int inf = 1000000007;
const ll linf = 1ll * inf * inf;
const ll MAXIMUM = 2005;
inline ll mul(ll a, ll b) { return (a * 1ll * b) % mod; }
inline ll sub(ll a, ll b) {
ll c = a - b;
if (c < 0)
c += mod;
return c;
}
inline ll add(ll a, ll b) {
ll c = a + b;
if (c >= mod)
c -= mod;
return c;
}
inline ll max(ll a, ll b) { return a > b ? a : b; }
inline ll minim(ll a, ll b) { return a < b ? a : b; }
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
ll power(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modInverse(ll n, ll p) { return power(n, p - 2, p); }
ll lcm(ll a, ll b) { return (a * b) / __gcd(a, b); }
bool comp(const point &p1, const point &p2) {
if (p1.first != p2.first)
return p1.first < p2.first;
else
return p1.second < p2.second;
}
string to(char x) {
string s(1, x);
return s;
}
ll dp[N];
ll rec(ll s, vector<vector<ll>> &graph) {
if (graph[s].size() == 0)
return 0;
else if (dp[s] != -1)
return dp[s];
else {
ll ans = dp[s];
for (ll i = 0; i < graph[s].size(); i++) {
ans = max(ans, 1 + rec(graph[s][i], graph));
}
return ans;
}
}
int main() {
fio;
ll n;
cin >> n;
ll m;
cin >> m;
vector<vector<ll>> graph(n);
f(m) {
ll x, y;
cin >> x >> y;
x--;
y--;
graph[x].pb(y);
}
fill(dp, -1);
ll ans = 0;
for (ll i = 0; i < n; i++) {
ans = max(ans, rec(i, graph));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define watch(x) cout << (#x) << " is " << (x) << endl
#define f(t) for (ll i = 0; i < t; i++)
#define bs(a, x) binary_search(a.begin(), a.end(), x)
#define ll long long int
#define ul unsigned long int
#define ld long double
#define umpi unordered_map<int, int>
#define umpl unordered_map<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define fill(a, p) memset(a, p, sizeof(a))
#define pb push_back
#define mod 1000000007
#define N 100005
#define all(a) a.begin(), a.end()
#define point pair<ll, ll>
#define endl "\n"
const int inf = 1000000007;
const ll linf = 1ll * inf * inf;
const ll MAXIMUM = 2005;
inline ll mul(ll a, ll b) { return (a * 1ll * b) % mod; }
inline ll sub(ll a, ll b) {
ll c = a - b;
if (c < 0)
c += mod;
return c;
}
inline ll add(ll a, ll b) {
ll c = a + b;
if (c >= mod)
c -= mod;
return c;
}
inline ll max(ll a, ll b) { return a > b ? a : b; }
inline ll minim(ll a, ll b) { return a < b ? a : b; }
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
ll power(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modInverse(ll n, ll p) { return power(n, p - 2, p); }
ll lcm(ll a, ll b) { return (a * b) / __gcd(a, b); }
bool comp(const point &p1, const point &p2) {
if (p1.first != p2.first)
return p1.first < p2.first;
else
return p1.second < p2.second;
}
string to(char x) {
string s(1, x);
return s;
}
ll dp[N];
ll rec(ll s, vector<vector<ll>> &graph) {
if (graph[s].size() == 0)
return 0;
else if (dp[s] != -1)
return dp[s];
else {
ll &ans = dp[s];
for (ll i = 0; i < graph[s].size(); i++) {
ans = max(ans, 1 + rec(graph[s][i], graph));
}
return ans;
}
}
int main() {
fio;
ll n;
cin >> n;
ll m;
cin >> m;
vector<vector<ll>> graph(n);
f(m) {
ll x, y;
cin >> x >> y;
x--;
y--;
graph[x].pb(y);
}
fill(dp, -1);
ll ans = 0;
for (ll i = 0; i < n; i++) {
ans = max(ans, rec(i, graph));
}
cout << ans << endl;
}
|
replace
| 89 | 90 | 89 | 90 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define f first
#define s second
vi c[100005];
bool visit[100005];
int ind[100005];
int dp[100005];
void dfs(int x) {
visit[x] = true;
for (int y : c[x]) {
dp[y] = max(dp[y], dp[x] + 1);
// ind[y]--;
// if(ind[y] == 0){
dfs(y);
//}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
c[a].pb(b);
ind[b]++;
}
for (int i = 1; i <= n; i++) {
if (!visit[i] && !ind[i]) {
dfs(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
/*
Things to look out for:
- Integer overflows
- Array bounds
- Special cases
Be careful!
*/
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define f first
#define s second
vi c[100005];
bool visit[100005];
int ind[100005];
int dp[100005];
void dfs(int x) {
visit[x] = true;
for (int y : c[x]) {
dp[y] = max(dp[y], dp[x] + 1);
ind[y]--;
if (ind[y] == 0) {
dfs(y);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
c[a].pb(b);
ind[b]++;
}
for (int i = 1; i <= n; i++) {
if (!visit[i] && !ind[i]) {
dfs(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
/*
Things to look out for:
- Integer overflows
- Array bounds
- Special cases
Be careful!
*/
|
replace
| 20 | 24 | 20 | 24 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAX 2000000
#define MOD 1000000007
#define INF 10000000000000000
using Graph = vector<vector<int>>;
int dfs(Graph G, int v, vector<int> &length, vector<bool> &seen) {
if (seen.at(v)) {
return length.at(v);
}
seen.at(v) = true;
int ans = 0;
for (auto nv : G.at(v)) {
ans = max(ans, dfs(G, nv, length, seen) + 1);
}
return length.at(v) = ans;
}
int main() {
int N, M;
cin >> N >> M;
Graph G(N);
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--, y--;
G.at(x).push_back(y);
}
vector<int> length(N, 0);
vector<bool> seen(N, false);
for (int i = 0; i < N; i++) {
dfs(G, i, length, seen);
}
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(ans, length.at(i));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAX 2000000
#define MOD 1000000007
#define INF 10000000000000000
using Graph = vector<vector<int>>;
int dfs(Graph &G, int v, vector<int> &length, vector<bool> &seen) {
if (seen.at(v)) {
return length.at(v);
}
seen.at(v) = true;
int ans = 0;
for (auto nv : G.at(v)) {
ans = max(ans, dfs(G, nv, length, seen) + 1);
}
return length.at(v) = ans;
}
int main() {
int N, M;
cin >> N >> M;
Graph G(N);
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--, y--;
G.at(x).push_back(y);
}
vector<int> length(N, 0);
vector<bool> seen(N, false);
for (int i = 0; i < N; i++) {
dfs(G, i, length, seen);
}
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(ans, length.at(i));
}
cout << ans << endl;
}
|
replace
| 8 | 9 | 8 | 9 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define MAX 2000005
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#define vi vector<ll>
#define vp vector<pii>
#define all(v) v.begin(), v.end()
#define lb(v, x) lower_bound(all(v), x)
#define ub(v, x) upper_bound(all(v), x)
#define sz(x) (ll) x.size()
#define F first
#define S second
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define ROF(i, a, b) for (ll i = a; i >= b; --i)
#define trace(x) cerr << #x << ": " << x << '\n';
typedef long long ll;
using namespace std;
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update>
ll mexp(ll a, ll b) {
ll ans = 1;
a %= MOD;
while (b) {
if (b & 1)
ans = ans * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return ans;
}
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
const int N = 100005;
vi g[N];
ll dist[N];
ll dfs(int u) {
if (dist[u] != -1) {
return dist[u];
}
ll d = 0;
for (int v : g[u]) {
d = max(d, dfs(v));
}
d = d + 1;
return d;
}
int main() {
IOS
FOR(i,0,N+1){
dist[i] = -1;
}
int n, m;
cin >> n >> m;
FOR(i, 0, m) {
int x, y;
cin >> x >> y;
g[x].pb(y);
}
ll ans = 0;
FOR(i, 1, n + 1) { ans = max(ans, dfs(i) - 1); }
cout << ans;
cerr << 1.0 / CLOCKS_PER_SEC << endl;
return 0;
}
|
#include <bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define MAX 2000005
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#define vi vector<ll>
#define vp vector<pii>
#define all(v) v.begin(), v.end()
#define lb(v, x) lower_bound(all(v), x)
#define ub(v, x) upper_bound(all(v), x)
#define sz(x) (ll) x.size()
#define F first
#define S second
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define ROF(i, a, b) for (ll i = a; i >= b; --i)
#define trace(x) cerr << #x << ": " << x << '\n';
typedef long long ll;
using namespace std;
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update>
ll mexp(ll a, ll b) {
ll ans = 1;
a %= MOD;
while (b) {
if (b & 1)
ans = ans * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return ans;
}
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
const int N = 100005;
vi g[N];
ll dist[N];
ll dfs(int u) {
if (dist[u] != -1) {
return dist[u];
}
ll d = 0;
for (int v : g[u]) {
d = max(d, dfs(v));
}
dist[u] = d + 1;
return dist[u];
}
int main() {
IOS
FOR(i,0,N+1){
dist[i] = -1;
}
int n, m;
cin >> n >> m;
FOR(i, 0, m) {
int x, y;
cin >> x >> y;
g[x].pb(y);
}
ll ans = 0;
FOR(i, 1, n + 1) { ans = max(ans, dfs(i) - 1); }
cout << ans;
cerr << 1.0 / CLOCKS_PER_SEC << endl;
return 0;
}
|
replace
| 61 | 63 | 61 | 63 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
// 最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dp[101010];
ll n, m;
vector<vector<ll>> to;
ll rec(ll v) {
if (dp[v] != -1)
return dp[v];
else {
ll res = 0;
for (auto nv : to[v]) {
res = max(res, rec(nv) + 1);
}
return dp[v] = res;
}
}
// long longしか使わない
// 素数は1より大きい
int main() {
cin >> n >> m;
rep(i, m) {
ll x, y;
cin >> x >> y;
x--;
y--;
to[x].push_back(y);
}
rep(i, n) { dp[i] = -1; }
ll ans = 0;
rep(i, n) { ans = max(ans, rec(i)); }
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
// 最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dp[101010];
ll n, m;
vector<vector<ll>> to;
ll rec(ll v) {
if (dp[v] != -1)
return dp[v];
else {
ll res = 0;
for (auto nv : to[v]) {
res = max(res, rec(nv) + 1);
}
return dp[v] = res;
}
}
// long longしか使わない
// 素数は1より大きい
int main() {
cin >> n >> m;
to.resize(n);
rep(i, m) {
ll x, y;
cin >> x >> y;
x--;
y--;
to[x].push_back(y);
}
rep(i, n) { dp[i] = -1; }
ll ans = 0;
rep(i, n) { ans = max(ans, rec(i)); }
cout << ans << endl;
return 0;
}
|
insert
| 63 | 63 | 63 | 64 |
-11
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define N 100009
#define INF 1000000009
#define MOD 1000000007
typedef long long int ll;
#define sd(x) scanf("%d", &x)
#define sd2(x, y) scanf("%d%d", &x, &y)
#define sd3(x, y, z) scanf("%lld%lld%lld", &x, &y, &z)
#define pf(x) printf("%d", x);
#define pf2(x, y) printf("%d %d\n", x, y);
#define pf3(x, y, z) printf("%d %d %d\n", x, y, z);
#define fi first
#define se second
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define _ \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define tr(x) cout << x << endl;
#define tr2(x, y) cout << x << " " << y << " " << endl;
#define tr3(x, y, z) cout << x << " " << y << " " << z << endl;
#define tr4(x, y, z, a) \
cout << x << " " << y << " " << z << " " << a << " " << endl;
int a[N], b[N], t;
vector<int> v[N], temp;
bool visit1[N], visit2[N];
void dfs1(int i) {
visit1[i] = 1;
for (auto j : v[i]) {
if (!visit1[j])
dfs1(j);
}
// tr(i);
temp.pb(i);
}
int ans = 0;
void dfs2(int i) {
visit2[i] = 1;
for (auto j : v[i]) {
dfs2(j);
a[i] = max(a[i], a[j] + 1);
}
ans = max(ans, a[i]);
}
int main() {
int i, j, n, m, t, k, x, y;
sd2(n, m);
for (i = 0; i < m; i++) {
sd2(x, y);
v[x].push_back(y);
}
for (i = 1; i <= n; i++) {
if (!visit1[i]) {
dfs1(i);
}
}
reverse(temp.begin(), temp.end());
for (auto i : temp) {
if (!visit2[i]) {
dfs2(i);
}
}
tr(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
#define N 100009
#define INF 1000000009
#define MOD 1000000007
typedef long long int ll;
#define sd(x) scanf("%d", &x)
#define sd2(x, y) scanf("%d%d", &x, &y)
#define sd3(x, y, z) scanf("%lld%lld%lld", &x, &y, &z)
#define pf(x) printf("%d", x);
#define pf2(x, y) printf("%d %d\n", x, y);
#define pf3(x, y, z) printf("%d %d %d\n", x, y, z);
#define fi first
#define se second
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define _ \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define tr(x) cout << x << endl;
#define tr2(x, y) cout << x << " " << y << " " << endl;
#define tr3(x, y, z) cout << x << " " << y << " " << z << endl;
#define tr4(x, y, z, a) \
cout << x << " " << y << " " << z << " " << a << " " << endl;
int a[N], b[N], t;
vector<int> v[N], temp;
bool visit1[N], visit2[N];
void dfs1(int i) {
visit1[i] = 1;
for (auto j : v[i]) {
if (!visit1[j])
dfs1(j);
}
// tr(i);
temp.pb(i);
}
int ans = 0;
void dfs2(int i) {
visit2[i] = 1;
for (auto j : v[i]) {
if (!visit2[j])
dfs2(j);
a[i] = max(a[i], a[j] + 1);
}
ans = max(ans, a[i]);
}
int main() {
int i, j, n, m, t, k, x, y;
sd2(n, m);
for (i = 0; i < m; i++) {
sd2(x, y);
v[x].push_back(y);
}
for (i = 1; i <= n; i++) {
if (!visit1[i]) {
dfs1(i);
}
}
reverse(temp.begin(), temp.end());
for (auto i : temp) {
if (!visit2[i]) {
dfs2(i);
}
}
tr(ans);
}
|
replace
| 41 | 42 | 41 | 43 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
vector<int> depth;
vector<pair<int, int>> G;
int depthG(int n) {
if (depth[n] != -1)
return depth[n];
auto it = lower_bound(G.begin(), G.end(), make_pair(n, 0));
int ans = 0;
while (it != G.end() and *it < make_pair(n + 1, 0)) {
ans = max(ans, depthG(it->second) + 1);
it++;
}
return ans;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> dp(N, 0);
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G.emplace_back(x, y);
}
sort(G.begin(), G.end());
vector<int> _depth(N, -1);
depth = _depth;
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(ans, depthG(i));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> depth;
vector<pair<int, int>> G;
int depthG(int n) {
if (depth[n] != -1)
return depth[n];
auto it = lower_bound(G.begin(), G.end(), make_pair(n, 0));
int ans = 0;
while (it != G.end() and *it < make_pair(n + 1, 0)) {
ans = max(ans, depthG(it->second) + 1);
it++;
}
return depth[n] = ans;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> dp(N, 0);
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G.emplace_back(x, y);
}
sort(G.begin(), G.end());
vector<int> _depth(N, -1);
depth = _depth;
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(ans, depthG(i));
}
cout << ans << endl;
}
|
replace
| 16 | 17 | 16 | 17 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #include <boost/multiprecision/cpp_ll.hpp>
// typedef boost::multiprecision::cpp_ll ll;
typedef long double dd;
#define i_7 (ll)(1E9 + 7)
// #define i_7 998244353
#define i_5 i_7 - 2
ll mod(ll a) {
ll c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
typedef pair<ll, ll> l_l;
ll inf = (ll)1E16;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define pb push_back
ll max(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll min(ll a, ll b) {
if (a > b)
return b;
else
return a;
}
void Max(ll &pos, ll val) { pos = max(pos, val); } // Max(dp[n],dp[n-1]);
void Min(ll &pos, ll val) { pos = min(pos, val); }
void Add(ll &pos, ll val) { pos = mod(pos + val); }
dd EPS = 1E-9;
string alp = "abcdefghijklmnopqrstuvwxyz";
#define endl "\n"
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
ll memo[100001];
vector<ll> v[100001];
ll hoge(ll i) {
if (memo[i] != 0) {
return memo[i];
}
if (v[i].size() == 0) {
return 0;
}
ll ans = 0;
rep(j, 0, v[i].size() - 1) { ans = max(ans, hoge(v[i][j]) + 1); }
return ans;
}
int main() {
fastio ll n, m;
cin >> n >> m;
ll x, y;
rep(i, 0, m - 1) {
cin >> x >> y;
v[x].pb(y);
}
ll ans = 0;
rep(i, 1, n) { ans = max(ans, hoge(i)); }
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #include <boost/multiprecision/cpp_ll.hpp>
// typedef boost::multiprecision::cpp_ll ll;
typedef long double dd;
#define i_7 (ll)(1E9 + 7)
// #define i_7 998244353
#define i_5 i_7 - 2
ll mod(ll a) {
ll c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
typedef pair<ll, ll> l_l;
ll inf = (ll)1E16;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define pb push_back
ll max(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll min(ll a, ll b) {
if (a > b)
return b;
else
return a;
}
void Max(ll &pos, ll val) { pos = max(pos, val); } // Max(dp[n],dp[n-1]);
void Min(ll &pos, ll val) { pos = min(pos, val); }
void Add(ll &pos, ll val) { pos = mod(pos + val); }
dd EPS = 1E-9;
string alp = "abcdefghijklmnopqrstuvwxyz";
#define endl "\n"
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
ll memo[100001];
vector<ll> v[100001];
ll hoge(ll i) {
if (memo[i] != 0) {
return memo[i];
}
if (v[i].size() == 0) {
return 0;
}
ll ans = 0;
rep(j, 0, v[i].size() - 1) { ans = max(ans, hoge(v[i][j]) + 1); }
return memo[i] = ans;
}
int main() {
fastio ll n, m;
cin >> n >> m;
ll x, y;
rep(i, 0, m - 1) {
cin >> x >> y;
v[x].pb(y);
}
ll ans = 0;
rep(i, 1, n) { ans = max(ans, hoge(i)); }
cout << ans << endl;
return 0;
}
|
replace
| 54 | 55 | 54 | 55 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
/*--ILRS-- sr4saurabh */
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define pb push_back
#define popb pop_back
#define mp make_pair
#define ve vector
#define vii vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vpl vector<pll>
#define fi first
#define sz size
#define len length
#define se second
// const ll mod=998244353;
const ll mod = 1000000000 + 7;
const ll N = 10000000 + 6;
#define M_PI 3.14159265358979323846
vii adj[100001];
int visited[100001] = {0};
int d[100001] = {0};
void dfs(int node) {
// cout<<node<<endl;
visited[node] = 1;
for (int v : adj[node]) {
if (!visited[v]) {
dfs(v);
}
d[node] = max(d[node], d[v] + 1);
}
d[node] = max(1, d[node]);
}
void bfs(int node) {
queue<int> q;
q.push(node);
visited[node] = 1;
while (!q.empty()) {
int v = q.front();
// cout<<v<<endl;
q.pop();
for (int g : adj[v])
if (!visited[g]) {
visited[g] = 1;
q.push(g);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("INPUT.txt", "r", stdin);
freopen("OUTPUT.txt", "w", stdout);
#endif
// for(int i=0;i<=100000;i++)
// visited[i]=0;
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].pb(v);
// adj[v].pb(u);
}
for (int j = 1; j <= n; j++) {
if (!visited[j])
dfs(j);
}
int ans = 0;
for (int j = 1; j <= n; j++) {
ans = max(ans, d[j]);
}
cout << ans - 1;
return 0;
}
|
/*--ILRS-- sr4saurabh */
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define pb push_back
#define popb pop_back
#define mp make_pair
#define ve vector
#define vii vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vpl vector<pll>
#define fi first
#define sz size
#define len length
#define se second
// const ll mod=998244353;
const ll mod = 1000000000 + 7;
const ll N = 10000000 + 6;
#define M_PI 3.14159265358979323846
vii adj[100001];
int visited[100001] = {0};
int d[100001] = {0};
void dfs(int node) {
// cout<<node<<endl;
visited[node] = 1;
for (int v : adj[node]) {
if (!visited[v]) {
dfs(v);
}
d[node] = max(d[node], d[v] + 1);
}
d[node] = max(1, d[node]);
}
void bfs(int node) {
queue<int> q;
q.push(node);
visited[node] = 1;
while (!q.empty()) {
int v = q.front();
// cout<<v<<endl;
q.pop();
for (int g : adj[v])
if (!visited[g]) {
visited[g] = 1;
q.push(g);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// #ifndef ONLINE_JUDGE
// freopen ("INPUT.txt" , "r" , stdin);
// freopen ("OUTPUT.txt", "w" , stdout);
// #endif
// for(int i=0;i<=100000;i++)
// visited[i]=0;
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].pb(v);
// adj[v].pb(u);
}
for (int j = 1; j <= n; j++) {
if (!visited[j])
dfs(j);
}
int ans = 0;
for (int j = 1; j <= n; j++) {
ans = max(ans, d[j]);
}
cout << ans - 1;
return 0;
}
|
replace
| 55 | 59 | 55 | 59 |
-11
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
int dfs(int v, vector<vector<int>> to, vector<int> &dist) {
if (dist[v] >= 0)
return dist[v];
int res = 0;
for (auto e : to[v])
res = max(res, dfs(e, to, dist) + 1);
dist[v] = res;
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<int>> to(n);
rep(i, m) {
int x, y;
cin >> x >> y;
x--;
y--;
to[x].push_back(y);
}
vector<int> dist(n, -1);
int ans = 0;
rep(i, n) { ans = max(ans, dfs(i, to, dist)); }
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
int dfs(int v, vector<vector<int>> &to, vector<int> &dist) {
if (dist[v] >= 0)
return dist[v];
int res = 0;
for (auto e : to[v])
res = max(res, dfs(e, to, dist) + 1);
dist[v] = res;
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<int>> to(n);
rep(i, m) {
int x, y;
cin >> x >> y;
x--;
y--;
to[x].push_back(y);
}
vector<int> dist(n, -1);
int ans = 0;
rep(i, n) { ans = max(ans, dfs(i, to, dist)); }
cout << ans << endl;
}
|
replace
| 9 | 10 | 9 | 10 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define assert_range(x, a, b) assert((a) <= (x) and (x) <= (b))
using ll = long long;
const int INF = 1e9;
const int N = 1e5;
vector<int> g[N];
bool visited[N];
void dfs(int v, vector<int> &order) {
for (auto u : g[v]) {
if (visited[u])
continue;
dfs(u, order);
}
order.push_back(v);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int v, u;
cin >> v >> u;
--v, --u;
g[v].push_back(u);
}
vector<int> order;
for (int i = 0; i < n; ++i) {
if (visited[i])
continue;
dfs(i, order);
}
vector<int> dp(n);
for (auto v : order) {
for (auto u : g[v]) {
dp[v] = max(dp[v], dp[u] + 1);
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
res = max(res, dp[i]);
}
cout << res << endl;
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define assert_range(x, a, b) assert((a) <= (x) and (x) <= (b))
using ll = long long;
const int INF = 1e9;
const int N = 1e5;
vector<int> g[N];
bool visited[N];
void dfs(int v, vector<int> &order) {
visited[v] = true;
for (auto u : g[v]) {
if (visited[u])
continue;
dfs(u, order);
}
order.push_back(v);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int v, u;
cin >> v >> u;
--v, --u;
g[v].push_back(u);
}
vector<int> order;
for (int i = 0; i < n; ++i) {
if (visited[i])
continue;
dfs(i, order);
}
vector<int> dp(n);
for (auto v : order) {
for (auto u : g[v]) {
dp[v] = max(dp[v], dp[u] + 1);
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
res = max(res, dp[i]);
}
cout << res << endl;
return 0;
}
|
insert
| 25 | 25 | 25 | 26 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[323456];
int cnt[323456];
int ans;
int d[323456];
vector<int> ord;
bool used[323456];
void dfs(int v) {
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to])
dfs(to);
}
ord.push_back(v);
}
void bfs() {
queue<int> q;
for (int i = 0; i < ord.size(); i++)
q.push(ord[i]);
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i];
if (d[x] + 1 > d[y])
d[y] = d[x] + 1, q.push(y), ans = max(ans, d[y]);
}
}
cout << ans;
exit(0);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
cnt[y]++;
// g[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (used[i] == 0)
dfs(i);
sort(ord.begin(), ord.end());
bfs();
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[323456];
int cnt[323456];
int ans;
int d[323456];
vector<int> ord;
bool used[323456];
void dfs(int v) {
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to])
dfs(to);
}
ord.push_back(v);
}
void bfs() {
queue<int> q;
for (int i = 0; i < ord.size(); i++)
q.push(ord[i]);
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i];
if (d[x] + 1 > d[y])
d[y] = d[x] + 1, q.push(y), ans = max(ans, d[y]);
}
}
cout << ans;
exit(0);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
cnt[y]++;
// g[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (used[i] == 0)
dfs(i);
reverse(ord.begin(), ord.end());
bfs();
cout << ans;
}
|
replace
| 52 | 53 | 52 | 53 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int vertices, edges;
vector<int> grp[10005];
vector<int> dp(10005, -1);
vector<int> visited(10005, -1);
int findMaxAns(int src) {
if (dp[src] != -1) {
return dp[src];
}
visited[src] = 1;
int maxPath = 0;
for (auto m : grp[src]) {
maxPath = max(maxPath, 1 + findMaxAns(m));
}
dp[src] = maxPath;
return dp[src];
}
void solve() {
cin >> vertices >> edges;
for (int i = 0; i < edges; i++) {
int a, b;
cin >> a >> b;
grp[a].push_back(b);
}
int ans = 0;
for (int i = 1; i <= vertices; i++) {
ans = max(ans, findMaxAns(i));
}
cout << ans;
}
int main() {
solve();
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int vertices, edges;
vector<int> grp[100005];
vector<int> dp(100005, -1);
vector<int> visited(100005, -1);
int findMaxAns(int src) {
if (dp[src] != -1) {
return dp[src];
}
visited[src] = 1;
int maxPath = 0;
for (auto m : grp[src]) {
maxPath = max(maxPath, 1 + findMaxAns(m));
}
dp[src] = maxPath;
return dp[src];
}
void solve() {
cin >> vertices >> edges;
for (int i = 0; i < edges; i++) {
int a, b;
cin >> a >> b;
grp[a].push_back(b);
}
int ans = 0;
for (int i = 1; i <= vertices; i++) {
ans = max(ans, findMaxAns(i));
}
cout << ans;
}
int main() {
solve();
return 0;
}
|
replace
| 9 | 12 | 9 | 12 |
0
| |
p03166
|
C++
|
Runtime Error
|
/* Don’t Quit
When things go wrong as they sometimes will;
When the road you’re trudging seems all uphill;
When the funds are low, and the debts are high;
And you want to smile, but you have to sigh;
When care is pressing you down a bit
Rest if you must, but don’t you
quit.
*/
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(0)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
// #define int long long
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
vector<int> vp[N];
int dp[N];
int go(int n) {
if (dp[n] != -1)
return dp[n];
int ans = 0;
for (int i = 0; i < vp[n].size(); i++) {
ans = max(ans, go(vp[n][i]) + 1);
}
dp[n] = ans;
return ans;
}
int main() {
int n, m;
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
vp[x].pb(y);
vp[y].pb(x);
}
int ans = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
ans = max(ans, go(i));
}
cout << ans << endl;
}
|
/* Don’t Quit
When things go wrong as they sometimes will;
When the road you’re trudging seems all uphill;
When the funds are low, and the debts are high;
And you want to smile, but you have to sigh;
When care is pressing you down a bit
Rest if you must, but don’t you
quit.
*/
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(0)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
// #define int long long
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
vector<int> vp[N];
int dp[N];
int go(int n) {
if (dp[n] != -1)
return dp[n];
int ans = 0;
for (int i = 0; i < vp[n].size(); i++) {
ans = max(ans, go(vp[n][i]) + 1);
}
dp[n] = ans;
return ans;
}
int main() {
int n, m;
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
vp[x].pb(y);
}
int ans = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
ans = max(ans, go(i));
}
cout << ans << endl;
}
|
delete
| 48 | 49 | 48 | 48 |
-11
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define N_MAX 100000
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
int dp[N_MAX + 5];
vector<int> G[N_MAX];
int N, M;
int dfs(int node) {
if (dp[node] != -1)
return dp[node];
int ans = 0;
for (auto x : G[node]) {
ans = max(ans, dfs(x) + 1);
}
return dp[node] = ans;
}
int main(void) {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int from, to;
cin >> from >> to;
G[from].push_back(to);
}
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 1; i <= N; i++) {
ans = max(ans, dfs(i));
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define N_MAX 100000
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
int dp[N_MAX + 5];
vector<int> G[N_MAX + 10];
int N, M;
int dfs(int node) {
if (dp[node] != -1)
return dp[node];
int ans = 0;
for (auto x : G[node]) {
ans = max(ans, dfs(x) + 1);
}
return dp[node] = ans;
}
int main(void) {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int from, to;
cin >> from >> to;
G[from].push_back(to);
}
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 1; i <= N; i++) {
ans = max(ans, dfs(i));
}
cout << ans << endl;
return 0;
}
|
replace
| 24 | 25 | 24 | 25 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define ll long long int
#define N 1e6
using namespace std;
/******* All Required define Pre-Processors and typedef Constants *******/
#define SCD(t) scanf("%d", &t)
#define SCLD(t) scanf("%ld", &t)
#define SCLLD(t) scanf("%lld", &t)
#define SCC(t) scanf("%c", &t)
#define SCS(t) scanf("%s", t)
#define SCF(t) scanf("%f", &t)
#define SCLF(t) scanf("%lf", &t)
#define MEM(a, b) memset(a, (b), sizeof(a))
#define FOR(i, j, k, in) for (int i = j; i < k; i += in)
#define RFOR(i, j, k, in) for (int i = j; i >= k; i -= in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define IN(A, B, C) assert(B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
const double pi = acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int, int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef unsigned long long int uint64;
vector<vector<int>> gV(100005 + 1);
int dP[100005] = {0};
bool vis[100005] = {false};
void dfs(int i) {
if (vis[i] == true) {
return;
}
vis[i] = true;
FOR(j, 0, gV[i].size(), 1) {
int nei = gV[i][j];
if (!vis[nei]) {
dfs(nei);
}
dP[i] = max(dP[i], dP[nei] + 1);
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
FOR(i, 0, m, 1) {
int x, y;
cin >> x >> y;
gV[x].PB(y);
}
FOR(i, 1, n + 1, 1) {
if (!vis[i]) {
dfs(i);
}
}
int max = INT_MIN;
FOR(i, 1, n + 1, 1) {
if (dP[i] > max) {
max = dP[i];
}
}
cout << max << endl;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define N 1e6
using namespace std;
/******* All Required define Pre-Processors and typedef Constants *******/
#define SCD(t) scanf("%d", &t)
#define SCLD(t) scanf("%ld", &t)
#define SCLLD(t) scanf("%lld", &t)
#define SCC(t) scanf("%c", &t)
#define SCS(t) scanf("%s", t)
#define SCF(t) scanf("%f", &t)
#define SCLF(t) scanf("%lf", &t)
#define MEM(a, b) memset(a, (b), sizeof(a))
#define FOR(i, j, k, in) for (int i = j; i < k; i += in)
#define RFOR(i, j, k, in) for (int i = j; i >= k; i -= in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define IN(A, B, C) assert(B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
const double pi = acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int, int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef unsigned long long int uint64;
vector<vector<int>> gV(100005 + 1);
int dP[100005] = {0};
bool vis[100005] = {false};
void dfs(int i) {
if (vis[i] == true) {
return;
}
vis[i] = true;
FOR(j, 0, gV[i].size(), 1) {
int nei = gV[i][j];
if (!vis[nei]) {
dfs(nei);
}
dP[i] = max(dP[i], dP[nei] + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
FOR(i, 0, m, 1) {
int x, y;
cin >> x >> y;
gV[x].PB(y);
}
FOR(i, 1, n + 1, 1) {
if (!vis[i]) {
dfs(i);
}
}
int max = INT_MIN;
FOR(i, 1, n + 1, 1) {
if (dP[i] > max) {
max = dP[i];
}
}
cout << max << endl;
}
|
delete
| 65 | 69 | 65 | 65 |
0
| |
p03166
|
C++
|
Runtime Error
|
// simple dfs not enough coz constraints of order 10^5 are high for normal
// recursion
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define ll long long
#define int long long
#define double long double
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define mkp make_pair
#define pb push_back
#define inf INT_MAX
vector<int> g[10005];
vector<int> dp;
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
int binomialCoeff(int n, int k) {
int res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
void printVector(vector<ll> v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
}
int divisor(int num) {
int div = 0;
for (int i = 1; i <= num; i++) {
/* code */
if (num % i == 0)
div++;
}
return div;
}
int sub(int a, int b) {
if (a >= b)
return a - b;
else
return b - a;
}
// this is like a modified DFS
// dp array stores overlapping substructures results & hence also does work of
// visited
int solve(int a) {
if (dp[a] != -1)
return dp[a];
int res = 0;
for (int i = 0; i < g[a].size(); i++)
res = max(res, solve(g[a][i]) + 1);
return dp[a] = res;
}
int32_t main() {
int n, m, x, y;
cin >> n >> m;
// dp[i]: stores max length in the graph starting from ith node
dp.resize(n + 2, -1);
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].pb(y);
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(ans, solve(i));
cout << ans;
return 0;
}
|
// simple dfs not enough coz constraints of order 10^5 are high for normal
// recursion
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define ll long long
#define int long long
#define double long double
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define mkp make_pair
#define pb push_back
#define inf INT_MAX
vector<int> g[110005];
vector<int> dp;
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
int binomialCoeff(int n, int k) {
int res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
void printVector(vector<ll> v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
}
int divisor(int num) {
int div = 0;
for (int i = 1; i <= num; i++) {
/* code */
if (num % i == 0)
div++;
}
return div;
}
int sub(int a, int b) {
if (a >= b)
return a - b;
else
return b - a;
}
// this is like a modified DFS
// dp array stores overlapping substructures results & hence also does work of
// visited
int solve(int a) {
if (dp[a] != -1)
return dp[a];
int res = 0;
for (int i = 0; i < g[a].size(); i++)
res = max(res, solve(g[a][i]) + 1);
return dp[a] = res;
}
int32_t main() {
int n, m, x, y;
cin >> n >> m;
// dp[i]: stores max length in the graph starting from ith node
dp.resize(n + 2, -1);
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].pb(y);
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(ans, solve(i));
cout << ans;
return 0;
}
|
replace
| 17 | 18 | 17 | 18 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define endl '\n'
#define vll vector<ll>
#define vvll vector<vll>
#define Cout(x) cout << #x << " " << x << endl
#define pll pair<ll, ll>
#define vpll vector<pll>
#define mp make_pair
#define pb push_back
#define MOD 1000000007
#define inf 1e18;
#define vfind(v, x) (find(all(v), x) != (v).end())
#define clr(c) (c).clear()
#define cres(c, n) (c).clear(), (c).resize(n)
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define fst first
#define scd second
#define eb(a) emplace_back(a)
#define ef(a) emplace_front(a)
#define fr(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define fr1(i, n) for (ll(i) = 1; (i) <= (n); ++(i))
#define frr(i, n) for (ll(i) = (n)-1; (i) >= 0; --(i))
#define frab(i, a, b, c) for (ll(i) = a; (i) <= (b); (i) += (c))
#define mst(A) memset((A), 0, sizeof(A));
using namespace std;
void write(vll &oneD) {
for (ll i = 0; i < oneD.size(); i++) {
printf("%lld ", oneD[i]);
}
printf("\n");
}
void write(vvll &twoD) {
for (ll i = 0; i < twoD.size(); i++) {
write(twoD[i]);
}
}
void write(vpll &oneDP) {
fr(i, oneDP.size()) { printf("%lld %lld\n", oneDP[i].fst, oneDP[i].scd); }
cout << "\n";
}
void write(map<ll, ll> &mpp) {
for (map<ll, ll>::iterator it = mpp.begin(); it != mpp.end(); it++) {
cout << it->fst << " : " << it->scd << endl;
}
cout << endl;
}
bool cmp(const pair<ll, ll> &a, const pair<ll, ll> &b) {
if (a.first == b.first)
return (a.scd >= b.scd);
return (a.first < b.first);
}
vll seive;
vll primes;
void Seive() {
const ll maxn = 100005;
seive.resize(maxn);
fr(i, maxn) seive[i] = 1;
for (ll i = 2; i * i < maxn; i++) {
if (seive[i] == 1) {
for (ll j = i * i; j < maxn; j += i) {
seive[j] = 0;
}
}
}
primes.pb(2);
for (ll i = 3; i < maxn; i += 2) {
if (seive[i])
primes.pb(i);
}
}
ll isprime(ll N) {
if (N < 2 || (!(N & 1) && N != 2))
return 0;
for (ll i = 3; i * i <= N; i += 2) {
if (!(N % i))
return 0;
}
return 1;
}
ll power(ll x, ll y, ll m) {
long long int res = 1;
x = x % m;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % MOD;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % MOD;
}
return res;
}
ll modinv(ll x, ll mod = MOD) { return power(x, mod - 2, mod); }
////////////////////////////////////////////////////////////////////////////////
ll A[1000005];
ll visited[100001];
ll indegree[100001];
vector<int> v[100005];
vll v1;
ll dis[100005];
ll n;
void dfs(ll x) {
visited[x] = 1;
for (auto it : v[x]) {
dis[it] = max(dis[it], 1 + dis[x]);
--indegree[it];
if (indegree[it] == 0) {
dfs(it);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("allo.txt", "r", stdin);
#endif
// freopen("out.txt","w",stdout);
ll a, b, c, d;
ll k, l, m, p, q, r, t, x, y;
// cin>>t;while(t--){ map<ll,ll> M; string s;
cin >> n >> m;
fr(i, m) {
cin >> a >> b;
v[a].pb(b);
indegree[b]++;
// cout<<A[i];
}
// exit(0);
fr1(i, n) {
if (!visited[i] && indegree[i] == 0)
dfs(i);
}
// exit(0);
ll mx = 0;
fr1(i, n) {
// cout<<dis[i]<<" "<<endl;
mx = max(mx, dis[i]);
}
cout << mx << endl;
// }
}
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define endl '\n'
#define vll vector<ll>
#define vvll vector<vll>
#define Cout(x) cout << #x << " " << x << endl
#define pll pair<ll, ll>
#define vpll vector<pll>
#define mp make_pair
#define pb push_back
#define MOD 1000000007
#define inf 1e18;
#define vfind(v, x) (find(all(v), x) != (v).end())
#define clr(c) (c).clear()
#define cres(c, n) (c).clear(), (c).resize(n)
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define fst first
#define scd second
#define eb(a) emplace_back(a)
#define ef(a) emplace_front(a)
#define fr(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define fr1(i, n) for (ll(i) = 1; (i) <= (n); ++(i))
#define frr(i, n) for (ll(i) = (n)-1; (i) >= 0; --(i))
#define frab(i, a, b, c) for (ll(i) = a; (i) <= (b); (i) += (c))
#define mst(A) memset((A), 0, sizeof(A));
using namespace std;
void write(vll &oneD) {
for (ll i = 0; i < oneD.size(); i++) {
printf("%lld ", oneD[i]);
}
printf("\n");
}
void write(vvll &twoD) {
for (ll i = 0; i < twoD.size(); i++) {
write(twoD[i]);
}
}
void write(vpll &oneDP) {
fr(i, oneDP.size()) { printf("%lld %lld\n", oneDP[i].fst, oneDP[i].scd); }
cout << "\n";
}
void write(map<ll, ll> &mpp) {
for (map<ll, ll>::iterator it = mpp.begin(); it != mpp.end(); it++) {
cout << it->fst << " : " << it->scd << endl;
}
cout << endl;
}
bool cmp(const pair<ll, ll> &a, const pair<ll, ll> &b) {
if (a.first == b.first)
return (a.scd >= b.scd);
return (a.first < b.first);
}
vll seive;
vll primes;
void Seive() {
const ll maxn = 100005;
seive.resize(maxn);
fr(i, maxn) seive[i] = 1;
for (ll i = 2; i * i < maxn; i++) {
if (seive[i] == 1) {
for (ll j = i * i; j < maxn; j += i) {
seive[j] = 0;
}
}
}
primes.pb(2);
for (ll i = 3; i < maxn; i += 2) {
if (seive[i])
primes.pb(i);
}
}
ll isprime(ll N) {
if (N < 2 || (!(N & 1) && N != 2))
return 0;
for (ll i = 3; i * i <= N; i += 2) {
if (!(N % i))
return 0;
}
return 1;
}
ll power(ll x, ll y, ll m) {
long long int res = 1;
x = x % m;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % MOD;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % MOD;
}
return res;
}
ll modinv(ll x, ll mod = MOD) { return power(x, mod - 2, mod); }
////////////////////////////////////////////////////////////////////////////////
ll A[1000005];
ll visited[100001];
ll indegree[100001];
vector<int> v[100005];
vll v1;
ll dis[100005];
ll n;
void dfs(ll x) {
visited[x] = 1;
for (auto it : v[x]) {
dis[it] = max(dis[it], 1 + dis[x]);
--indegree[it];
if (indegree[it] == 0) {
dfs(it);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll a, b, c, d;
ll k, l, m, p, q, r, t, x, y;
// cin>>t;while(t--){ map<ll,ll> M; string s;
cin >> n >> m;
fr(i, m) {
cin >> a >> b;
v[a].pb(b);
indegree[b]++;
// cout<<A[i];
}
// exit(0);
fr1(i, n) {
if (!visited[i] && indegree[i] == 0)
dfs(i);
}
// exit(0);
ll mx = 0;
fr1(i, n) {
// cout<<dis[i]<<" "<<endl;
mx = max(mx, dis[i]);
}
cout << mx << endl;
// }
}
|
delete
| 180 | 184 | 180 | 180 |
-11
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100005];
vector<int> toposort;
int vis[100005];
void topo(int x) {
if (vis[x])
return;
for (int i = 0; i < (int)adj[x].size(); i++) {
if (vis[adj[x][i]])
continue;
topo(adj[x][i]);
}
toposort.push_back(x);
}
int main() {
scanf("%d%d", &n, &m);
int x, y;
int indeg[n];
memset(indeg, 0, sizeof(indeg));
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
adj[x].push_back(y);
indeg[y]++;
}
int dp[n];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
if (indeg[i] == 0) {
topo(i);
}
}
reverse(toposort.begin(), toposort.end());
for (int i = 0; i < (int)toposort.size(); i++) {
for (int j = 0; j < (int)adj[toposort[i]].size(); j++) {
dp[adj[toposort[i]][j]] =
max(dp[adj[toposort[i]][j]], dp[toposort[i]] + 1);
}
}
int ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, dp[i]);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100005];
vector<int> toposort;
int vis[100005];
void topo(int x) {
if (vis[x])
return;
vis[x] = 1;
for (int i = 0; i < (int)adj[x].size(); i++) {
if (vis[adj[x][i]])
continue;
topo(adj[x][i]);
}
toposort.push_back(x);
}
int main() {
scanf("%d%d", &n, &m);
int x, y;
int indeg[n];
memset(indeg, 0, sizeof(indeg));
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
adj[x].push_back(y);
indeg[y]++;
}
int dp[n];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
if (indeg[i] == 0) {
topo(i);
}
}
reverse(toposort.begin(), toposort.end());
for (int i = 0; i < (int)toposort.size(); i++) {
for (int j = 0; j < (int)adj[toposort[i]].size(); j++) {
dp[adj[toposort[i]][j]] =
max(dp[adj[toposort[i]][j]], dp[toposort[i]] + 1);
}
}
int ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, dp[i]);
printf("%d", ans);
}
|
insert
| 11 | 11 | 11 | 12 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
/* Murad Eynizade */
#include <bits/stdc++.h>
#define intt long long
#define FAST_READ \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#define F first
#define S second
using namespace std;
const int sz = 100005;
int n, m, x, y, used[sz], ans[sz], mx;
vector<int> v[sz];
void dfs(int s) {
int res = 0;
for (int to : v[s]) {
if (!used[to])
dfs(to);
res = max(res, ans[to] + 1);
}
ans[s] = res;
mx = max(mx, ans[s]);
}
int main() {
FAST_READ;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
}
for (int i = 1; i <= n; i++)
if (!used[i])
dfs(i);
cout << mx << endl;
return 0;
}
|
/* Murad Eynizade */
#include <bits/stdc++.h>
#define intt long long
#define FAST_READ \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#define F first
#define S second
using namespace std;
const int sz = 100005;
int n, m, x, y, used[sz], ans[sz], mx;
vector<int> v[sz];
void dfs(int s) {
used[s] = 1;
int res = 0;
for (int to : v[s]) {
if (!used[to])
dfs(to);
res = max(res, ans[to] + 1);
}
ans[s] = res;
mx = max(mx, ans[s]);
}
int main() {
FAST_READ;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
}
for (int i = 1; i <= n; i++)
if (!used[i])
dfs(i);
cout << mx << endl;
return 0;
}
|
insert
| 19 | 19 | 19 | 20 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
vector<vector<int>> g;
vector<int> indegree;
vector<int> visited;
vector<int> depth;
void dfs(int v) {
visited[v] = 1;
for (int u : g[v]) {
depth[u] = max(depth[u], depth[v] + 1);
dfs(u);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
g.resize(n, vector<int>());
visited.resize(n);
indegree.resize(n);
depth.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
indegree[b]++;
}
for (int i = 0; i < n; i++) {
if (!visited[i] && indegree[i] == 0) {
dfs(i);
}
}
cout << *max_element(depth.begin(), depth.end());
#ifdef LOCAL
cerr << "\n";
#endif
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
vector<vector<int>> g;
vector<int> indegree;
vector<int> visited;
vector<int> depth;
void dfs(int v) {
visited[v] = 1;
for (int u : g[v]) {
depth[u] = max(depth[u], depth[v] + 1);
--indegree[u];
if (indegree[u] == 0)
dfs(u);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
g.resize(n, vector<int>());
visited.resize(n);
indegree.resize(n);
depth.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
indegree[b]++;
}
for (int i = 0; i < n; i++) {
if (!visited[i] && indegree[i] == 0) {
dfs(i);
}
}
cout << *max_element(depth.begin(), depth.end());
#ifdef LOCAL
cerr << "\n";
#endif
return 0;
}
|
replace
| 14 | 15 | 14 | 17 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define pii pair<int, int>
#define vi vector<int>
#define ll long long
#define pb push_back
#define mp make_pair
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define repf(i, st, end, inc) for (int i = st; i < end; i += inc)
#define repb(i, st, end, dec) for (int i = st; i >= end; i -= dec)
#define MOD 1000000007
#define trace1(a) cout << a << endl;
#define trace2(a, b) cout << a << " | " << b << endl;
#define trace3(a, b, c) cout << a << " | " << b << " | " << c << endl;
#define trace4(a, b, c, d) \
cout << a << " | " << b << " | " << c << " | " << d << endl;
using namespace std;
using namespace std::chrono;
void dfs(int st, vector<vector<int>> &g, vector<int> &visited,
vector<int> &topo_sort) {
visited[st] = 1;
for (int i = 0; i < g[st].size(); i++) {
if (visited[i] == g[st][i])
dfs(g[st][i], g, visited, topo_sort);
}
topo_sort.pb(st);
}
int main() {
fast;
#ifdef LOCAL_PROJECT
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
auto start = high_resolution_clock::now();
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
vector<int> in_deg(n, 0);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x - 1].pb(y - 1);
in_deg[y - 1]++;
}
vector<int> topo_sort;
vector<int> visited(n, 0);
for (int i = 0; i < n; i++) {
if (in_deg[i] == 0)
dfs(i, g, visited, topo_sort);
}
reverse(topo_sort.begin(), topo_sort.end());
vector<int> dp(n, 0);
for (int i = 0; i < n; i++) {
int node = topo_sort[i];
for (int j = 0; j < g[node].size(); j++) {
dp[g[node][j]] = max(dp[g[node][j]], 1 + dp[node]);
}
}
int ans = -1;
for (int i = 0; i < n; i++)
ans = max(ans, dp[i]);
cout << ans << "\n";
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
// cout << endl;
// cout << fixed << setprecision(9) << double(duration.count()) / 1000000 <<
// endl;
return 0;
}
|
#include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define pii pair<int, int>
#define vi vector<int>
#define ll long long
#define pb push_back
#define mp make_pair
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define repf(i, st, end, inc) for (int i = st; i < end; i += inc)
#define repb(i, st, end, dec) for (int i = st; i >= end; i -= dec)
#define MOD 1000000007
#define trace1(a) cout << a << endl;
#define trace2(a, b) cout << a << " | " << b << endl;
#define trace3(a, b, c) cout << a << " | " << b << " | " << c << endl;
#define trace4(a, b, c, d) \
cout << a << " | " << b << " | " << c << " | " << d << endl;
using namespace std;
using namespace std::chrono;
void dfs(int st, vector<vector<int>> &g, vector<int> &visited,
vector<int> &topo_sort) {
visited[st] = 1;
for (int i = 0; i < g[st].size(); i++) {
if (visited[g[st][i]] == 0)
dfs(g[st][i], g, visited, topo_sort);
}
topo_sort.pb(st);
}
int main() {
fast;
#ifdef LOCAL_PROJECT
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
auto start = high_resolution_clock::now();
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
vector<int> in_deg(n, 0);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x - 1].pb(y - 1);
in_deg[y - 1]++;
}
vector<int> topo_sort;
vector<int> visited(n, 0);
for (int i = 0; i < n; i++) {
if (in_deg[i] == 0)
dfs(i, g, visited, topo_sort);
}
reverse(topo_sort.begin(), topo_sort.end());
vector<int> dp(n, 0);
for (int i = 0; i < n; i++) {
int node = topo_sort[i];
for (int j = 0; j < g[node].size(); j++) {
dp[g[node][j]] = max(dp[g[node][j]], 1 + dp[node]);
}
}
int ans = -1;
for (int i = 0; i < n; i++)
ans = max(ans, dp[i]);
cout << ans << "\n";
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
// cout << endl;
// cout << fixed << setprecision(9) << double(duration.count()) / 1000000 <<
// endl;
return 0;
}
|
replace
| 44 | 45 | 44 | 45 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
vector<vector<int>> g(N);
vector<bool> vis(N);
vector<int> dp(N);
stack<int> topo;
void dfs(int u) {
vis[u] = 1;
for (auto v : g[u])
if (!vis[v])
dfs(v);
topo.push(u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
for (int i = 1; i <= n; i++)
if (!vis[i])
dfs(i);
for (; !topo.empty(); topo.pop()) {
int u = topo.top();
for (auto v : g[u])
dp[v] = max(dp[v], dp[u] + 1);
}
cout << *max_element(dp.begin() + 1, dp.end() + n + 1) << '\n';
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
vector<vector<int>> g(N);
vector<bool> vis(N);
vector<int> dp(N);
stack<int> topo;
void dfs(int u) {
vis[u] = 1;
for (auto v : g[u])
if (!vis[v])
dfs(v);
topo.push(u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
for (int i = 1; i <= n; i++)
if (!vis[i])
dfs(i);
for (; !topo.empty(); topo.pop()) {
int u = topo.top();
for (auto v : g[u])
dp[v] = max(dp[v], dp[u] + 1);
}
cout << *max_element(dp.begin() + 1, dp.begin() + n + 1) << '\n';
return 0;
}
|
replace
| 46 | 47 | 46 | 47 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#ifdef ONLINE_JUDGE
#define endl "\n"
#endif
using namespace std;
typedef unsigned long long int lu;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> v;
typedef vector<lu> vu;
typedef vector<v> vv;
typedef vector<vu> vvu;
typedef vector<ld> vld;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef pair<ll, ll> pll;
typedef vector<set<ll>> vsll;
typedef set<pair<ll, ll>> spll;
typedef vector<spll> vspll;
typedef vector<pll> vpll;
typedef pair<lu, lu> puu;
typedef vector<puu> vpuu;
const ll MOD = 1000000007;
const ld PI = 2 * acos(0.0);
const v dx = {1, -1, 0, 0};
const v dy = {0, 0, 1, -1};
#define round(x, y) ((x + y - 1) / y)
#define ce(x, y) ((x + y - 1) / y)
#define amax(x, y) \
if (y > x) \
x = y;
#define amin(x, y) \
if (y < x) \
x = y;
#define lcm(x, y) ((x) * (y) / __gcd(x, y))
#define sz(x) (ll) x.size()
#define sq(x) ((x) * (x))
#define cb(x) ((x) * (x) * (x))
#define yes cout << "YES\n";
#define no cout << "NO\n";
#define yesno(f) \
if (f) \
yes else no;
#define noo \
{ no return; }
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
template <typename T = ll> vector<T> ga(ll n, bool oneIndexed = false) {
vector<T> a = vector<T>(n + oneIndexed);
for (ll i = 0; i < n; i++) {
T p;
cin >> p;
a[i + oneIndexed] = p;
}
return move(a);
}
template <typename T, typename A>
void pa(vector<T, A> const &a, ll begin = 0, ll end = -1) {
if (end == -1)
end = sz(a) - 1;
for (ll i = begin; i <= end; i++) {
cout << a[i] << " ";
}
cout << endl;
}
void solve() {
ll n, m;
cin >> n >> m;
vv adjList(n + 1, v(0));
v indeg(n + 1, 0);
vv inci(n + 1, v(0));
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
adjList[a].push_back(b);
inci[b].push_back(a);
indeg[b]++;
}
queue<ll> degrees;
for (ll i = 1; i <= n; i++)
if (!indeg[i])
degrees.push(i);
v toposort = {-1};
while (!degrees.empty()) {
auto node = degrees.front();
degrees.pop();
toposort.push_back(node);
for (auto neigh : adjList[node]) {
indeg[neigh]--;
if (!indeg[neigh])
degrees.push(neigh);
}
}
v dp(n + 1, 0);
for (auto node : toposort) {
for (auto neigh : inci[node]) {
amax(dp[node], dp[neigh] + 1);
}
}
ll len = 0;
for (ll i = 1; i <= n; i++) {
amax(len, dp[i]);
}
cout << len;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("file", "r", stdin);
// freopen("file", "w", stdout);
// ll t;cin >> t;while(t--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
#ifdef ONLINE_JUDGE
#define endl "\n"
#endif
using namespace std;
typedef unsigned long long int lu;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> v;
typedef vector<lu> vu;
typedef vector<v> vv;
typedef vector<vu> vvu;
typedef vector<ld> vld;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef pair<ll, ll> pll;
typedef vector<set<ll>> vsll;
typedef set<pair<ll, ll>> spll;
typedef vector<spll> vspll;
typedef vector<pll> vpll;
typedef pair<lu, lu> puu;
typedef vector<puu> vpuu;
const ll MOD = 1000000007;
const ld PI = 2 * acos(0.0);
const v dx = {1, -1, 0, 0};
const v dy = {0, 0, 1, -1};
#define round(x, y) ((x + y - 1) / y)
#define ce(x, y) ((x + y - 1) / y)
#define amax(x, y) \
if (y > x) \
x = y;
#define amin(x, y) \
if (y < x) \
x = y;
#define lcm(x, y) ((x) * (y) / __gcd(x, y))
#define sz(x) (ll) x.size()
#define sq(x) ((x) * (x))
#define cb(x) ((x) * (x) * (x))
#define yes cout << "YES\n";
#define no cout << "NO\n";
#define yesno(f) \
if (f) \
yes else no;
#define noo \
{ no return; }
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
template <typename T = ll> vector<T> ga(ll n, bool oneIndexed = false) {
vector<T> a = vector<T>(n + oneIndexed);
for (ll i = 0; i < n; i++) {
T p;
cin >> p;
a[i + oneIndexed] = p;
}
return move(a);
}
template <typename T, typename A>
void pa(vector<T, A> const &a, ll begin = 0, ll end = -1) {
if (end == -1)
end = sz(a) - 1;
for (ll i = begin; i <= end; i++) {
cout << a[i] << " ";
}
cout << endl;
}
void solve() {
ll n, m;
cin >> n >> m;
vv adjList(n + 1, v(0));
v indeg(n + 1, 0);
vv inci(n + 1, v(0));
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
adjList[a].push_back(b);
inci[b].push_back(a);
indeg[b]++;
}
queue<ll> degrees;
for (ll i = 1; i <= n; i++)
if (!indeg[i])
degrees.push(i);
v toposort = {};
while (!degrees.empty()) {
auto node = degrees.front();
degrees.pop();
toposort.push_back(node);
for (auto neigh : adjList[node]) {
indeg[neigh]--;
if (!indeg[neigh])
degrees.push(neigh);
}
}
v dp(n + 1, 0);
for (auto node : toposort) {
for (auto neigh : inci[node]) {
amax(dp[node], dp[neigh] + 1);
}
}
ll len = 0;
for (ll i = 1; i <= n; i++) {
amax(len, dp[i]);
}
cout << len;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("file", "r", stdin);
// freopen("file", "w", stdout);
// ll t;cin >> t;while(t--)
solve();
return 0;
}
|
replace
| 90 | 91 | 90 | 91 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <string>
using namespace std;
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define endl '\n'
// #define N 1000012
// #define N 1000000000+5
#define ll long long
#define ld long double
#define lli long long
#define pb push_back
#define INF 10000000000
#define mod 1000000007
#define MOD 1000000007
#define mp make_pair
#define loop(n) for (lli i = 0; i < n; i++)
#define FOR(a, b) for (lli i = a; i < b; i += 1)
#define st(v) v.begin(), v.end()
#define F first
#define S second
#define mp make_pair
#define itr ::iterator it
#define w(t) \
cin >> t; \
while (t--)
#define inputarr(a, n) \
for (lli i = 0; i < n; i++) \
cin >> a[i];
#define input(a, n) \
for (lli i = 0; i < n; i++) { \
lli x; \
cin >> x; \
a.push_back(x); \
}
#define printarr(a, n) \
for (lli i = 0; i < n; i++) \
cout << a[i]; \
cout << endl;
#define print(vec) \
for (auto xt : vec) \
cout << xt; \
cout << endl;
#define printset(st) \
for (auto xt : st) \
cout << xt << " "; \
cout << endl;
const int N = (int)(1 * 1e6 + 10);
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// // typedef tree<int,null_type,less<int>,rb_tree_tag,
// // tree_order_statistics_node_update> indexed_set;
// typedef tree<int, null_type, less_equal<int>,
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
// lli v1[N], v3[N];
// std::vector<lli> v1[N];
// lli v2[N];
// lli ans[N], a[N];
// lli maxi=0;
// lli sqr(lli a){
// return a*a;
// }
// int n, k, m,l,a[200004],i;
// string s;
// int gcd(int a, int b, int& x, int& y) {
// if (b == 0) {
// x = 1;
// y = 0;
// return a;
// }
// int x1, y1;
// int d = gcd(b, a % b, x1, y1);
// x = y1;
// y = x1 - y1 * (a / b);
// return d;
// }
// int gcd(int a, int b, int &x, int &y)
// {
// int xx = y = 0;
// int yy = x = 1;
// while (b)
// {
// int q = a/b;
// int t = b; b = a%b; a = t;
// t = xx; xx = x-q*xx; x = t;
// t = yy; yy = y-q*yy; y = t;
// }
// return a;
// }
// bool find_any_solution(int a, int b, int c, int &x0, int &y0, int &g) {
// g = gcd(abs(a), abs(b), x0, y0);
// if (c % g !=0) {
// return false;
// }
// x0 *= c / g;
// y0 *= c / g;
// // cout<<x0<<" "<<y0<<endl;
// double t1 = ceil((-1.0 * x0 * g)/b);
// double t2 = floor((1.0 * y0 * g)/a);
// if (t2 >= t1)
// return true;
// else
// return false;
// }
// set<lli> s1;
// void seive(lli n,vector<lli> &primes){
// bool isprime[n+1];
// memset(isprime,true,n+1);
// for(lli i =2;i*i<=n;i++){
// if(isprime[i]==true){
// for(lli j=i*i;j<=n ;j+=i)
// isprime[j]=false;
// }
// }
// for(lli i =2;i<=n;i++){
// if(isprime[i]){
// primes.pb(i);
// }
// }
// }
// lli A,R,M,n,ans,k;
// lli a,b,x,y,m,c;
// string s;
// // bool is_prime(lli n){
// // if(n<=1)return false;
// // // if(n <= 1: return False
// // if (n <= 3) return true;
// // if(n%2==0 or n%3 == 0)return false;
// // lli r = int(sqrt(n));
// // lli f = 5;
// // while(f*f < n){
// // if(n%f == 0 || n%(f+2) == 0)return false;
// // f+= 6;
// // }
// // return true;
// // }
// bool is_prime(lli n)
// {
// // Corner cases
// if (n <= 1) return false;
// if (n <= 3) return true;
// // This is checked so that we can skip
// // middle five numbers in below loop
// if (n%2 == 0 || n%3 == 0) return false;
// for (lli i=5; i*i<=n; i=i+6)
// if (n%i == 0 || n%(i+2) == 0)
// return false;
// return true;
// }
// lli fun(lli n,vector<lli> &primes){
// lli l=n;
// lli c=0;
// // set<long long> factorization;
// // for(auto x: primes ){
// // cout<<x<<" ";
// // }
// for (long long d : primes) {
// lli f=0;
// if (d * d > n)
// break;
// while (n % d == 0) {
// f=1;
// // factorization.insert(d);
// n /= d;
// }
// if(f==1)c++;
// }
// if (n > 1)c++;
// // factorization.insert(n);
// // cout<<l<<" "<<factorization.size()<<endl;
// return c;
// // return c;
// }
// lli fun(lli n){
// return n*(n+1)/2;
// }
// lli fact(lli n){
// lli res=1;
// for(lli i =2;i<=n;i++){
// res*=i;
// }
// return res;
// }
// lli gcd(lli a,lli b){
// if(a==0){
// return b;
// }
// return gcd(b%a,a);
// }
// lli fac(lli n,lli k){
// lli maxi=1;
// for(lli i =1;i*i<=n;i++){
// if(n%i==0 &&i<=k){
// maxi=max(maxi,i);
// }
// if(n%i==0 && n/i<=k){
// maxi=max(maxi,n/i);
// }
// }
// return maxi;
// }
// // int a[N];
// int S[N];
// int freq[N];
// vector<int> good[N];
// lli some1(){
// S[1]=0;
// for(lli i =2;i<N;i++){
// if(!S[i]){
// // lli j=i;
// for(lli j=i;j<N;j+=i){
// S[j]+=i;
// }
// }
// }
// for(lli i =1;i<N;i++){
// // lli j=i;
// for(lli j=i;j<N;j+=i){
// if(S[i] && S[j]%S[i]==0){
// good[i].pb(j);
// }
// }
// }
// }
// lli totfac(lli n){
// // set<lli> s1;
// lli c=0;
// for(lli i=1;i*i<=n;i++){
// if(n%i==0){
// if(n/i ==i){
// c++;
// }
// else{
// c+=2;
// }
// }
// }
// return c;
// }
// lli somefun(lli a, lli b, lli m){
// lli res=1;
// while(b){
// if(b&1)
// res=res*a%m;
// a=a*a%m;
// b/=2;
// }
// return res;
// }
// lli lpf[N];
// void init(){
// lpf[1]=1;
// for(lli i =2;i<N;i++){
// lpf[i]=i;
// }
// for(lli i=2;i<N;i+=2)
// lpf[i]=2;
// for(lli i=3;i*i<N;i++){
// if(lpf[i]==i){
// for(lli j=i*i;j<N;j+=i){
// if(lpf[j]==j)
// lpf[j]=i;
// }
// }
// }
// }
// lli findGCD(std::vector<lli> &arr, lli n)
// {
// lli result = arr[0];
// for (int i = 1; i < n; i++)
// {
// result = gcd(arr[i], result);
// if(result == 1)
// {
// return 1;
// }
// }
// return result;
// }
// std::vector<lli> factorial(N+1);
// std::vector<lli> factorial2(N+1);
// // std::vector<lli> dp(N+1);
// std::vector<lli> invFact(N+1);
// lli nCr(lli n, lli r)
// {
// return (((factorial[n]*invFact[r])%MOD)*invFact[n-r])%MOD;
// }
// // lli val;
// // int pre[N];
// std::vector<lli> factval;
// lli printDivisors(lli n)
// {
// // Note that this loop runs till square root
// for (lli i=1; i*i<=n; i++)
// {
// if (n%i == 0)
// {
// // If divisors are equal, print only one
// factval.pb(i);
// if (n/i != i)
// factval.pb(n/i);
// // else // Otherwise print both
// // printf("%d %d ", i, n/i);
// }
// }
// return factval.size();
// }
// lli primefactorization(lli n){
// lli i=2,c=0;
// while(i*i<=n){
// if(n%i==0){
// while(n%i==0){
// n/=i;
// }
// c++;
// }
// i++;
// }
// if(n>1)c++;
// return c;
// }
// lli factorials(int n)
// {
// // single line to find factorial
// // return (n==1 || n==0) ? 1: n * factorials(n - 1);
// lli val=1;
// for(lli i =1;i<=n;i++)
// val=val*i%MOD;
// return val;
// }
// lli some(lli n,lli k){
// return factorials(n)/factorials(k)*factorials(n-k);
// }
// bool sum10(lli k){
// lli sum=0;
// while(k>0){
// sum+=k%10;
// k/=10;
// }
// return sum==10;
// }
// int n,x;
int bit[N];
// int fen[N];
void update(int i, int add) {
while (i > 0 && i < N) {
bit[i] += add;
i += (i & (-i));
}
}
int sum1(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i = i - (i & (-i));
}
return s;
}
// int n;
// void add(int idx, int val) {
// // cout<<idx<<endl;
// for (++idx; idx < N; idx += idx & -idx)
// bit[idx] += val;
// }
// void range_add(ll l, ll r, ll val) {
// // cout<<l<<" "<<r<<endl;
// add(l, val);
// add(r + 1, -val);
// }
// ll point_query(int idx) {
// int ret = 0;
// for (++idx; idx > 0; idx -= idx & -idx)
// ret += bit[idx];
// return ret;
// }
// void Update(int x, int add) {
// for (; x <= n; x += x & -x)
// bit[x] += add;
// }
// int Query(int x) {
// int answer = 0;
// for (; x; x -= x & -x)
// answer += bit[x];
// return answer;
// }
std::map<lli, lli> has;
set<lli> s1;
// bool sortdec(const pair<pair<ll,ll>,ll> &a,
// const pair<pair<ll,ll>,ll> &b){
// if(a.F.F<b.F.F)return true;
// else if(a.F.F==b.F.F)return a.F.S>b.F.S;
// else return false;
// }
lli n;
std::vector<string> v1(2);
std::vector<int> edges[N];
int visited[N];
int dist[N];
int indegree[N];
void dfs(int a) {
assert(!visited[a] == true);
visited[a] = true;
for (auto b : edges[a]) {
dist[b] = max(dist[b], dist[a] + 1);
--indegree[b];
if (indegree[b] == 0) {
dfs(b);
}
}
}
int32_t main() {
// your code goes here
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
// lli m,o,e,k,b,l,c,d,x,y,f,t,r,a;
// lli x,y,z,k,b,j,c,d,m;
// lli t,l,r,f,g,d,q,u;
// lli q;
// init(); //calculates prime factoriztion til 1e6
fastIO
// cin>>n>>d;
// phi_1_to_n();
// cout<<phi[5]<<endl;
// w(t){
// lli n,a,b,k;
lli h,
m, q, H, D, C, w, a, b;
cin >> n >> m;
while (m--) {
cin >> a >> b;
edges[a].pb(b);
++indegree[b];
}
for (lli i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
}
}
int ans = 0;
for (lli i = 1; i <= n; i++) {
ans = max(ans, dist[i]);
}
cout << ans;
// for(auto x: dp){
// cout<<x<<" ";
// }
// cout<<endl;
// cout<<*max_element(st(dp));
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
using namespace std;
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define endl '\n'
// #define N 1000012
// #define N 1000000000+5
#define ll long long
#define ld long double
#define lli long long
#define pb push_back
#define INF 10000000000
#define mod 1000000007
#define MOD 1000000007
#define mp make_pair
#define loop(n) for (lli i = 0; i < n; i++)
#define FOR(a, b) for (lli i = a; i < b; i += 1)
#define st(v) v.begin(), v.end()
#define F first
#define S second
#define mp make_pair
#define itr ::iterator it
#define w(t) \
cin >> t; \
while (t--)
#define inputarr(a, n) \
for (lli i = 0; i < n; i++) \
cin >> a[i];
#define input(a, n) \
for (lli i = 0; i < n; i++) { \
lli x; \
cin >> x; \
a.push_back(x); \
}
#define printarr(a, n) \
for (lli i = 0; i < n; i++) \
cout << a[i]; \
cout << endl;
#define print(vec) \
for (auto xt : vec) \
cout << xt; \
cout << endl;
#define printset(st) \
for (auto xt : st) \
cout << xt << " "; \
cout << endl;
const int N = (int)(1 * 1e6 + 10);
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// // typedef tree<int,null_type,less<int>,rb_tree_tag,
// // tree_order_statistics_node_update> indexed_set;
// typedef tree<int, null_type, less_equal<int>,
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
// lli v1[N], v3[N];
// std::vector<lli> v1[N];
// lli v2[N];
// lli ans[N], a[N];
// lli maxi=0;
// lli sqr(lli a){
// return a*a;
// }
// int n, k, m,l,a[200004],i;
// string s;
// int gcd(int a, int b, int& x, int& y) {
// if (b == 0) {
// x = 1;
// y = 0;
// return a;
// }
// int x1, y1;
// int d = gcd(b, a % b, x1, y1);
// x = y1;
// y = x1 - y1 * (a / b);
// return d;
// }
// int gcd(int a, int b, int &x, int &y)
// {
// int xx = y = 0;
// int yy = x = 1;
// while (b)
// {
// int q = a/b;
// int t = b; b = a%b; a = t;
// t = xx; xx = x-q*xx; x = t;
// t = yy; yy = y-q*yy; y = t;
// }
// return a;
// }
// bool find_any_solution(int a, int b, int c, int &x0, int &y0, int &g) {
// g = gcd(abs(a), abs(b), x0, y0);
// if (c % g !=0) {
// return false;
// }
// x0 *= c / g;
// y0 *= c / g;
// // cout<<x0<<" "<<y0<<endl;
// double t1 = ceil((-1.0 * x0 * g)/b);
// double t2 = floor((1.0 * y0 * g)/a);
// if (t2 >= t1)
// return true;
// else
// return false;
// }
// set<lli> s1;
// void seive(lli n,vector<lli> &primes){
// bool isprime[n+1];
// memset(isprime,true,n+1);
// for(lli i =2;i*i<=n;i++){
// if(isprime[i]==true){
// for(lli j=i*i;j<=n ;j+=i)
// isprime[j]=false;
// }
// }
// for(lli i =2;i<=n;i++){
// if(isprime[i]){
// primes.pb(i);
// }
// }
// }
// lli A,R,M,n,ans,k;
// lli a,b,x,y,m,c;
// string s;
// // bool is_prime(lli n){
// // if(n<=1)return false;
// // // if(n <= 1: return False
// // if (n <= 3) return true;
// // if(n%2==0 or n%3 == 0)return false;
// // lli r = int(sqrt(n));
// // lli f = 5;
// // while(f*f < n){
// // if(n%f == 0 || n%(f+2) == 0)return false;
// // f+= 6;
// // }
// // return true;
// // }
// bool is_prime(lli n)
// {
// // Corner cases
// if (n <= 1) return false;
// if (n <= 3) return true;
// // This is checked so that we can skip
// // middle five numbers in below loop
// if (n%2 == 0 || n%3 == 0) return false;
// for (lli i=5; i*i<=n; i=i+6)
// if (n%i == 0 || n%(i+2) == 0)
// return false;
// return true;
// }
// lli fun(lli n,vector<lli> &primes){
// lli l=n;
// lli c=0;
// // set<long long> factorization;
// // for(auto x: primes ){
// // cout<<x<<" ";
// // }
// for (long long d : primes) {
// lli f=0;
// if (d * d > n)
// break;
// while (n % d == 0) {
// f=1;
// // factorization.insert(d);
// n /= d;
// }
// if(f==1)c++;
// }
// if (n > 1)c++;
// // factorization.insert(n);
// // cout<<l<<" "<<factorization.size()<<endl;
// return c;
// // return c;
// }
// lli fun(lli n){
// return n*(n+1)/2;
// }
// lli fact(lli n){
// lli res=1;
// for(lli i =2;i<=n;i++){
// res*=i;
// }
// return res;
// }
// lli gcd(lli a,lli b){
// if(a==0){
// return b;
// }
// return gcd(b%a,a);
// }
// lli fac(lli n,lli k){
// lli maxi=1;
// for(lli i =1;i*i<=n;i++){
// if(n%i==0 &&i<=k){
// maxi=max(maxi,i);
// }
// if(n%i==0 && n/i<=k){
// maxi=max(maxi,n/i);
// }
// }
// return maxi;
// }
// // int a[N];
// int S[N];
// int freq[N];
// vector<int> good[N];
// lli some1(){
// S[1]=0;
// for(lli i =2;i<N;i++){
// if(!S[i]){
// // lli j=i;
// for(lli j=i;j<N;j+=i){
// S[j]+=i;
// }
// }
// }
// for(lli i =1;i<N;i++){
// // lli j=i;
// for(lli j=i;j<N;j+=i){
// if(S[i] && S[j]%S[i]==0){
// good[i].pb(j);
// }
// }
// }
// }
// lli totfac(lli n){
// // set<lli> s1;
// lli c=0;
// for(lli i=1;i*i<=n;i++){
// if(n%i==0){
// if(n/i ==i){
// c++;
// }
// else{
// c+=2;
// }
// }
// }
// return c;
// }
// lli somefun(lli a, lli b, lli m){
// lli res=1;
// while(b){
// if(b&1)
// res=res*a%m;
// a=a*a%m;
// b/=2;
// }
// return res;
// }
// lli lpf[N];
// void init(){
// lpf[1]=1;
// for(lli i =2;i<N;i++){
// lpf[i]=i;
// }
// for(lli i=2;i<N;i+=2)
// lpf[i]=2;
// for(lli i=3;i*i<N;i++){
// if(lpf[i]==i){
// for(lli j=i*i;j<N;j+=i){
// if(lpf[j]==j)
// lpf[j]=i;
// }
// }
// }
// }
// lli findGCD(std::vector<lli> &arr, lli n)
// {
// lli result = arr[0];
// for (int i = 1; i < n; i++)
// {
// result = gcd(arr[i], result);
// if(result == 1)
// {
// return 1;
// }
// }
// return result;
// }
// std::vector<lli> factorial(N+1);
// std::vector<lli> factorial2(N+1);
// // std::vector<lli> dp(N+1);
// std::vector<lli> invFact(N+1);
// lli nCr(lli n, lli r)
// {
// return (((factorial[n]*invFact[r])%MOD)*invFact[n-r])%MOD;
// }
// // lli val;
// // int pre[N];
// std::vector<lli> factval;
// lli printDivisors(lli n)
// {
// // Note that this loop runs till square root
// for (lli i=1; i*i<=n; i++)
// {
// if (n%i == 0)
// {
// // If divisors are equal, print only one
// factval.pb(i);
// if (n/i != i)
// factval.pb(n/i);
// // else // Otherwise print both
// // printf("%d %d ", i, n/i);
// }
// }
// return factval.size();
// }
// lli primefactorization(lli n){
// lli i=2,c=0;
// while(i*i<=n){
// if(n%i==0){
// while(n%i==0){
// n/=i;
// }
// c++;
// }
// i++;
// }
// if(n>1)c++;
// return c;
// }
// lli factorials(int n)
// {
// // single line to find factorial
// // return (n==1 || n==0) ? 1: n * factorials(n - 1);
// lli val=1;
// for(lli i =1;i<=n;i++)
// val=val*i%MOD;
// return val;
// }
// lli some(lli n,lli k){
// return factorials(n)/factorials(k)*factorials(n-k);
// }
// bool sum10(lli k){
// lli sum=0;
// while(k>0){
// sum+=k%10;
// k/=10;
// }
// return sum==10;
// }
// int n,x;
int bit[N];
// int fen[N];
void update(int i, int add) {
while (i > 0 && i < N) {
bit[i] += add;
i += (i & (-i));
}
}
int sum1(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i = i - (i & (-i));
}
return s;
}
// int n;
// void add(int idx, int val) {
// // cout<<idx<<endl;
// for (++idx; idx < N; idx += idx & -idx)
// bit[idx] += val;
// }
// void range_add(ll l, ll r, ll val) {
// // cout<<l<<" "<<r<<endl;
// add(l, val);
// add(r + 1, -val);
// }
// ll point_query(int idx) {
// int ret = 0;
// for (++idx; idx > 0; idx -= idx & -idx)
// ret += bit[idx];
// return ret;
// }
// void Update(int x, int add) {
// for (; x <= n; x += x & -x)
// bit[x] += add;
// }
// int Query(int x) {
// int answer = 0;
// for (; x; x -= x & -x)
// answer += bit[x];
// return answer;
// }
std::map<lli, lli> has;
set<lli> s1;
// bool sortdec(const pair<pair<ll,ll>,ll> &a,
// const pair<pair<ll,ll>,ll> &b){
// if(a.F.F<b.F.F)return true;
// else if(a.F.F==b.F.F)return a.F.S>b.F.S;
// else return false;
// }
lli n;
std::vector<string> v1(2);
std::vector<int> edges[N];
int visited[N];
int dist[N];
int indegree[N];
void dfs(int a) {
assert(!visited[a] == true);
visited[a] = true;
for (auto b : edges[a]) {
dist[b] = max(dist[b], dist[a] + 1);
--indegree[b];
if (indegree[b] == 0) {
dfs(b);
}
}
}
int32_t main() {
// your code goes here
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
// lli m,o,e,k,b,l,c,d,x,y,f,t,r,a;
// lli x,y,z,k,b,j,c,d,m;
// lli t,l,r,f,g,d,q,u;
// lli q;
// init(); //calculates prime factoriztion til 1e6
fastIO
// cin>>n>>d;
// phi_1_to_n();
// cout<<phi[5]<<endl;
// w(t){
// lli n,a,b,k;
lli h,
m, q, H, D, C, w, a, b;
cin >> n >> m;
while (m--) {
cin >> a >> b;
edges[a].pb(b);
++indegree[b];
}
for (lli i = 1; i <= n; i++) {
if (!visited[i] && indegree[i] == 0) {
dfs(i);
}
}
int ans = 0;
for (lli i = 1; i <= n; i++) {
ans = max(ans, dist[i]);
}
cout << ans;
// for(auto x: dp){
// cout<<x<<" ";
// }
// cout<<endl;
// cout<<*max_element(st(dp));
return 0;
}
|
replace
| 502 | 503 | 502 | 503 |
-11
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int u, vector<int> adj[], vector<int> &dp, vector<bool> vis) {
int i, j;
vis[u] = true;
for (i = 0; i < adj[u].size(); i++) {
if (vis[adj[u][i]] == false)
dfs(adj[u][i], adj, dp, vis);
dp[u] = max(dp[u], 1 + dp[adj[u][i]]);
}
}
int main() {
int n, m, i, j, u, v;
cin >> n >> m;
vector<int> adj[n + 1];
for (i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
}
vector<int> dp(n + 1, 0);
vector<bool> vis(n + 1, false);
int ans = -1;
for (i = 1; i <= n; i++) {
if (vis[i] == false)
dfs(i, adj, dp, vis);
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int u, vector<int> adj[], vector<int> &dp, vector<bool> &vis) {
int i, j;
vis[u] = true;
for (i = 0; i < adj[u].size(); i++) {
if (vis[adj[u][i]] == false)
dfs(adj[u][i], adj, dp, vis);
dp[u] = max(dp[u], 1 + dp[adj[u][i]]);
}
}
int main() {
int n, m, i, j, u, v;
cin >> n >> m;
vector<int> adj[n + 1];
for (i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
}
vector<int> dp(n + 1, 0);
vector<bool> vis(n + 1, false);
int ans = -1;
for (i = 1; i <= n; i++) {
if (vis[i] == false)
dfs(i, adj, dp, vis);
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, s, e) for (int(i) = (s); (i) <= (e); ++(i))
#define all(x) x.begin(), x.end()
int n, m;
vector<vector<int>> g;
int dp[100100];
int dfs(int now) {
if (dp[now] != -1)
return dp[now];
int res = 0;
for (int x : g[now]) {
res = max(res, dfs(x) + 1);
}
return dp[now] = res;
}
int main() {
cin >> n >> m;
g.resize(n);
rep(i, 1, m) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
}
rep(i, 0, 100100) dp[i] = -1;
int res = 0;
rep(i, 0, n - 1) res = max(res, dfs(i));
cout << res << endl;
}
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, s, e) for (int(i) = (s); (i) <= (e); ++(i))
#define all(x) x.begin(), x.end()
int n, m;
vector<vector<int>> g;
int dp[100100];
int dfs(int now) {
if (dp[now] != -1)
return dp[now];
int res = 0;
for (int x : g[now]) {
res = max(res, dfs(x) + 1);
}
return dp[now] = res;
}
int main() {
cin >> n >> m;
g.resize(n);
rep(i, 1, m) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
}
rep(i, 0, 100010) dp[i] = -1;
int res = 0;
rep(i, 0, n - 1) res = max(res, dfs(i));
cout << res << endl;
}
|
replace
| 40 | 41 | 40 | 41 |
0
| |
p03166
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
const unsigned long long MAXN = 3001;
const int MAXI = (int)2e9;
const ll INF = (1e18);
vector<vector<int>> g(MAXN, vector<int>());
int in_degree[MAXN], dp[MAXN];
bool was[MAXN];
void dfs(int v) {
assert(!was[v]);
was[v] = 1;
for (int to : g[v]) {
dp[to] = max(dp[to], dp[v] + 1);
in_degree[to]--;
if (in_degree[to] == 0)
dfs(to);
}
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int u, w;
cin >> u >> w;
g[u].push_back(w);
in_degree[w]++;
}
for (int i = 1; i <= n; i++) {
if (!was[i] && in_degree[i] == 0) {
dfs(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
const unsigned long long MAXN = int(1e5) + 5;
const ll INF = (1e18);
vector<vector<int>> g(MAXN, vector<int>());
int in_degree[MAXN], dp[MAXN];
bool was[MAXN];
void dfs(int v) {
assert(!was[v]);
was[v] = 1;
for (int to : g[v]) {
dp[to] = max(dp[to], dp[v] + 1);
in_degree[to]--;
if (in_degree[to] == 0)
dfs(to);
}
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int u, w;
cin >> u >> w;
g[u].push_back(w);
in_degree[w]++;
}
for (int i = 1; i <= n; i++) {
if (!was[i] && in_degree[i] == 0) {
dfs(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
return 0;
}
|
replace
| 33 | 35 | 33 | 34 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
// G - Longest Path
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
int in() {
int x;
scanf("%d", &x);
return x;
}
#define VMAX 100000
vvi V(VMAX);
vi D(VMAX, -1);
int dfs(int p) {
int a = D[p];
if (a > -1)
return a;
for (int c : V[p])
a = max(a, dfs(c) + 1);
return a;
}
int main() {
int N, M;
cin >> N >> M;
while (M--)
V[in() - 1].push_back(in() - 1);
int a = 0;
while (N--)
a = max(a, dfs(N) + 1);
cout << a << endl;
}
|
// G - Longest Path
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
int in() {
int x;
scanf("%d", &x);
return x;
}
#define VMAX 100000
vvi V(VMAX);
vi D(VMAX, -1);
int dfs(int p) {
int &a = D[p];
if (a > -1)
return a;
for (int c : V[p])
a = max(a, dfs(c) + 1);
return a;
}
int main() {
int N, M;
cin >> N >> M;
while (M--)
V[in() - 1].push_back(in() - 1);
int a = 0;
while (N--)
a = max(a, dfs(N) + 1);
cout << a << endl;
}
|
replace
| 16 | 17 | 16 | 17 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <vector>
#define LL long long
using namespace std;
int n, m, d1, d2, dp[100005], vis[100005];
vector<int> v[100005];
int dfs(int x, int k) {
// cout << x << " " << k << "\n";
int MMM = 0;
if (dp[x] != 0)
return dp[x] + k;
if (v[x].empty())
return k;
for (auto i : v[x]) {
// cout << x << " " << i << "\n";
MMM = max(dfs(i, k + 1), MMM);
}
return MMM;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> d1 >> d2, v[d2].push_back(d1);
}
int Max = 0;
for (int i = 1; i <= n; i++) {
dp[i] = dfs(i, 0);
Max = max(dp[i], Max);
}
cout << Max;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
#define LL long long
using namespace std;
int n, m, d1, d2, dp[100005], vis[100005];
vector<int> v[100005];
int dfs(int x, int k) {
// cout << x << " " << k << "\n";
int MMM = 0;
if (dp[x] != 0)
return dp[x] + k;
if (v[x].empty())
return k;
for (auto i : v[x]) {
// cout << x << " " << i << "\n";
dp[i] = dfs(i, k + 1);
MMM = max(dp[i], MMM);
dp[i] -= (k + 1);
}
return MMM;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> d1 >> d2, v[d2].push_back(d1);
}
int Max = 0;
for (int i = 1; i <= n; i++) {
dp[i] = dfs(i, 0);
Max = max(dp[i], Max);
}
cout << Max;
}
|
replace
| 16 | 17 | 16 | 19 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
vector<vector<int>> vec;
vector<int> dp;
void dfs(int i) {
if (vec[i].size() == 0) {
dp[i] = 0;
}
for (auto v : vec[i]) {
if (dp[v] = -1)
dfs(v);
dp[i] = max(dp[v] + 1, dp[i]);
}
}
int main() {
int n, m;
cin >> n >> m;
vec.assign(n, vector<int>(0));
dp.assign(n, -1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
vec[a].pb(b);
}
int mx = -1;
for (int i = 0; i < n; i++) {
if (dp[i] == -1)
dfs(i);
mx = max(mx, dp[i]);
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
vector<vector<int>> vec;
vector<int> dp;
void dfs(int i) {
if (vec[i].size() == 0) {
dp[i] = 0;
}
for (auto v : vec[i]) {
if (dp[v] == -1)
dfs(v);
dp[i] = max(dp[v] + 1, dp[i]);
}
}
int main() {
int n, m;
cin >> n >> m;
vec.assign(n, vector<int>(0));
dp.assign(n, -1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
vec[a].pb(b);
}
int mx = -1;
for (int i = 0; i < n; i++) {
if (dp[i] == -1)
dfs(i);
mx = max(mx, dp[i]);
}
cout << mx << endl;
}
|
replace
| 11 | 12 | 11 | 12 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define ll long long int
#define ar array
#define bigint int64_t
#define vll vector<ll>
#define pll ar<ll, 2>
#define vpll vector<pll>
#define pb push_back
#define MOD 1000000007
#define sz(x) (ll)(x).size()
#define ff first
#define ss second
#define en cout << "\n"
#define LCM(a, b) (a * (b / __gcd(a, b)))
#define all(v) v.begin(), v.end()
#define maxqueue priority_queue<int>
#define minqueue priority_queue<int, vector<int>, greater<int>>
#define lb(v, val) (lower_bound(v.begin(), v.end(), val) - v.begin())
#define ub(v, val) (upper_bound(v.begin(), v.end(), val) - v.begin())
#define INF (ll)(1e18)
#define ini(a, b) memset(a, b, sizeof(a))
#define vvll vector<vector<ll>>
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define prec(n) fixed << setprecision(n)
#define F_OR(i, a, b, s) \
for (int i = (a); ((s) > 0 ? i < (b) : i > (b)); i += (s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define forn(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define deb1(x) cerr << #x << ": " << x << endl
#define deb2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define deb3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define deb4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define deb5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define deb6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
#define GET5(a, b, c, d, e, ...) e
#define D_EBC(...) GET5(__VA_ARGS__, deb4, deb3, deb2, deb1)
#define deb(...) D_EBC(__VA_ARGS__)(__VA_ARGS__)
#define each(x, a) for (auto &x : a)
using namespace std;
template <typename T> void read(T &x) { cin >> x; }
template <typename T, typename T0> void read(T &x, T0 &y) { cin >> x >> y; }
template <typename T, typename T0, typename T1> void read(T &x, T0 &y, T1 &z) {
cin >> x >> y >> z;
}
template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
cin >> x >> y >> z >> w;
}
template <typename T> void read(vector<T> &oneD, ll n) {
for (ll i = 0; i < n; i++) {
read(oneD[i]);
}
}
template <typename T> void read(T oneD[], ll n) {
for (ll i = 0; i < n; i++) {
read(oneD[i]);
}
}
const ll N = 1e5;
ll dp[N + 1], n, m;
vll g[N + 1];
void dfs(ll i) {
each(u, g[i]) {
dfs(u);
dp[i] = max(dp[i], dp[u] + 1);
}
}
void solve() {
read(n, m);
forn(i, m) {
ll a, b;
read(a, b);
--a, --b;
g[a].pb(b);
}
ll ans = 0;
forn(i, n) {
if (!dp[i])
dfs(i);
}
cout << *(max_element(dp, dp + N));
}
int main() {
fast;
int t = 1;
// read(t);
forn(t) {
// cout << "Case #" << i+1 << ": ";
solve();
}
}
|
#include <bits/stdc++.h>
#define ll long long int
#define ar array
#define bigint int64_t
#define vll vector<ll>
#define pll ar<ll, 2>
#define vpll vector<pll>
#define pb push_back
#define MOD 1000000007
#define sz(x) (ll)(x).size()
#define ff first
#define ss second
#define en cout << "\n"
#define LCM(a, b) (a * (b / __gcd(a, b)))
#define all(v) v.begin(), v.end()
#define maxqueue priority_queue<int>
#define minqueue priority_queue<int, vector<int>, greater<int>>
#define lb(v, val) (lower_bound(v.begin(), v.end(), val) - v.begin())
#define ub(v, val) (upper_bound(v.begin(), v.end(), val) - v.begin())
#define INF (ll)(1e18)
#define ini(a, b) memset(a, b, sizeof(a))
#define vvll vector<vector<ll>>
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define prec(n) fixed << setprecision(n)
#define F_OR(i, a, b, s) \
for (int i = (a); ((s) > 0 ? i < (b) : i > (b)); i += (s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define forn(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define deb1(x) cerr << #x << ": " << x << endl
#define deb2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define deb3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define deb4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define deb5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define deb6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
#define GET5(a, b, c, d, e, ...) e
#define D_EBC(...) GET5(__VA_ARGS__, deb4, deb3, deb2, deb1)
#define deb(...) D_EBC(__VA_ARGS__)(__VA_ARGS__)
#define each(x, a) for (auto &x : a)
using namespace std;
template <typename T> void read(T &x) { cin >> x; }
template <typename T, typename T0> void read(T &x, T0 &y) { cin >> x >> y; }
template <typename T, typename T0, typename T1> void read(T &x, T0 &y, T1 &z) {
cin >> x >> y >> z;
}
template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
cin >> x >> y >> z >> w;
}
template <typename T> void read(vector<T> &oneD, ll n) {
for (ll i = 0; i < n; i++) {
read(oneD[i]);
}
}
template <typename T> void read(T oneD[], ll n) {
for (ll i = 0; i < n; i++) {
read(oneD[i]);
}
}
const ll N = 1e5;
ll dp[N + 1], n, m;
vll g[N + 1];
void dfs(ll i) {
each(u, g[i]) {
if (dp[u]) {
dp[i] = max(dp[i], dp[u] + 1);
continue;
}
dfs(u);
dp[i] = max(dp[i], dp[u] + 1);
}
}
void solve() {
read(n, m);
forn(i, m) {
ll a, b;
read(a, b);
--a, --b;
g[a].pb(b);
}
ll ans = 0;
forn(i, n) {
if (!dp[i])
dfs(i);
}
cout << *(max_element(dp, dp + N));
}
int main() {
fast;
int t = 1;
// read(t);
forn(t) {
// cout << "Case #" << i+1 << ": ";
solve();
}
}
|
insert
| 88 | 88 | 88 | 92 |
TLE
| |
p03166
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define pb push_back
typedef long long ll;
const int MAXN = 3e3 + 5;
const int MAXW = 1e5 + 5;
const int MOD = 1e9 + 7;
using namespace std;
vector<int> g[MAXN];
int mem[MAXN];
int solve(int u, int c) {
if (g[u].empty())
return 0;
int &ret = mem[u];
if (ret != -1)
return ret;
ret = -1e9;
for (auto &k : g[u])
ret = max(ret, solve(k, c + 1) + 1);
return ret;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
memset(mem, -1, sizeof(mem));
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, solve(i, 0));
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define pb push_back
typedef long long ll;
const int MAXN = 1e5 + 5;
const int MAXW = 1e5 + 5;
const int MOD = 1e9 + 7;
using namespace std;
vector<int> g[MAXN];
int mem[MAXN];
int solve(int u, int c) {
if (g[u].empty())
return 0;
int &ret = mem[u];
if (ret != -1)
return ret;
ret = -1e9;
for (auto &k : g[u])
ret = max(ret, solve(k, c + 1) + 1);
return ret;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
memset(mem, -1, sizeof(mem));
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, solve(i, 0));
}
cout << ans;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <assert.h>
#include <climits>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
template <typename T> T gcd(T a, T b) {
if (a < b)
gcd(b, a);
if (b == 1)
return 1;
T r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
#define MOD (1000000000 + 7)
bool _less(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> E;
vector<int> inedges(N), outedges(N);
vector<vector<int>> nextnodes(N);
REP(i, M) {
int x, y;
cin >> x >> y;
E.push_back(make_pair(x - 1, y - 1));
inedges[y - 1]++;
outedges[x - 1]++;
nextnodes[x - 1].push_back(y - 1);
}
vector<int> dp(N);
REP(i, N) {
if (outedges[i] == 0)
dp[i] = 1;
}
auto rec = [&](auto f, int n) mutable -> int {
if (dp[n] > 0)
return dp[n];
int m = 0;
REP(i, nextnodes[n].size()) {
int nn = nextnodes[n][i];
m = max(m, f(f, nn) + 1);
}
return m;
};
int cnt = 0;
REP(i, N) {
if (inedges[i] == 0) {
cnt = max(cnt, rec(rec, i));
}
}
cout << cnt - 1 << endl;
}
|
#include <algorithm>
#include <assert.h>
#include <climits>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
template <typename T> T gcd(T a, T b) {
if (a < b)
gcd(b, a);
if (b == 1)
return 1;
T r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
#define MOD (1000000000 + 7)
bool _less(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> E;
vector<int> inedges(N), outedges(N);
vector<vector<int>> nextnodes(N);
REP(i, M) {
int x, y;
cin >> x >> y;
E.push_back(make_pair(x - 1, y - 1));
inedges[y - 1]++;
outedges[x - 1]++;
nextnodes[x - 1].push_back(y - 1);
}
vector<int> dp(N);
REP(i, N) {
if (outedges[i] == 0)
dp[i] = 1;
}
auto rec = [&](auto f, int n) mutable -> int {
if (dp[n] > 0)
return dp[n];
int m = 0;
REP(i, nextnodes[n].size()) {
int nn = nextnodes[n][i];
m = max(m, f(f, nn) + 1);
}
dp[n] = m;
return m;
};
int cnt = 0;
REP(i, N) {
if (inedges[i] == 0) {
cnt = max(cnt, rec(rec, i));
}
}
cout << cnt - 1 << endl;
}
|
insert
| 64 | 64 | 64 | 65 |
TLE
| |
p03166
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <limits.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define pb push_back
#define mp make_pair
#define sz(a) a.size()
#define fi first
#define se second
#define rsz(a, n) a.resize(n)
#define test(t) \
ll t; \
cin >> t; \
while (t--)
#define forn(i, e) for (int i = 0; i < e; i++)
#define forsn(i, s, e) for (int i = s; i < e; i++)
#define rforn(i, s) for (int i = s; i >= 0; i--)
#define rforsn(i, s, e) for (int i = s; i >= e; i--)
#define fillv(a, k) memset(a, k, sizeof(a))
#define filla(a, k, n) memset(a, k, sizeof(a[0]) * n)
#define leadzero(a) __builtin_clz(a) // count leading zeros
#define trailzero(a) __builtin_ctz(a) // count trailing zeros
#define bitcount(a) __builtin_popcount(a) // count set bits (add ll)
#define ln cout << "\n"
#define sp cout << " "
#define spaceprint(a, i, s, n) \
{ \
forsn(i, s, n) { \
cout << a[i]; \
sp; \
} \
}
#define lineprint(a, i, s, n) \
{ \
forsn(i, s, n) { \
cout << a[i]; \
ln; \
} \
}
#define maxe(a) *max_element(a.begin(), a.end())
#define maxi(a) max_element(a.begin(), a.end()) - a.begin()
#define mine(a) *min_element(a.begin(), a.end())
#define mini(a) min_element(a.begin(), a.end()) - a.begin()
#define all(c) c.begin(), c.end()
#define trav(container, it) \
for (typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define present(container, element) (container.find(element) != container.end())
#define cpresent(container, element) \
(find(all(container), element) != \
container.end()) // check the presence of element
// copy(from_begin, from_end, to_begin); copy function
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<ll, ll> p64;
typedef pair<int, int> p32;
typedef pair<int, p32> p96;
typedef vector<ll> v64;
typedef vector<string> vs;
typedef vector<int> v32;
typedef vector<v32> vv32;
typedef vector<v64> vv64;
typedef vector<p32> vp32;
typedef vector<p64> vp64;
typedef vector<vp32> vvp32;
typedef map<int, int> m32;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
#define sumv(v) accumulate(all(v), ll(0))
#define productv(v) accumulate(all(v), ll(1), multiplies<ll>())
ll dp[100003];
ll n, m;
v64 v[100003];
ll solve(ll i) {
if (dp[i] != -1)
return dp[i];
ll maxx = 0;
for (ll j = 0; j < v[i].size(); j++) {
maxx = max(maxx, solve(v[i][j]) + 1);
}
return maxx;
}
int main() {
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll x, y;
cin >> x >> y;
v[x].pb(y);
}
fillv(dp, -1);
ll maxx = 0;
for (ll i = 1; i <= n; i++) {
if (dp[i] == -1)
dp[i] = solve(i);
maxx = max(dp[i], maxx);
}
cout << maxx << endl;
}
|
#include <bits/stdc++.h>
#include <limits.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define pb push_back
#define mp make_pair
#define sz(a) a.size()
#define fi first
#define se second
#define rsz(a, n) a.resize(n)
#define test(t) \
ll t; \
cin >> t; \
while (t--)
#define forn(i, e) for (int i = 0; i < e; i++)
#define forsn(i, s, e) for (int i = s; i < e; i++)
#define rforn(i, s) for (int i = s; i >= 0; i--)
#define rforsn(i, s, e) for (int i = s; i >= e; i--)
#define fillv(a, k) memset(a, k, sizeof(a))
#define filla(a, k, n) memset(a, k, sizeof(a[0]) * n)
#define leadzero(a) __builtin_clz(a) // count leading zeros
#define trailzero(a) __builtin_ctz(a) // count trailing zeros
#define bitcount(a) __builtin_popcount(a) // count set bits (add ll)
#define ln cout << "\n"
#define sp cout << " "
#define spaceprint(a, i, s, n) \
{ \
forsn(i, s, n) { \
cout << a[i]; \
sp; \
} \
}
#define lineprint(a, i, s, n) \
{ \
forsn(i, s, n) { \
cout << a[i]; \
ln; \
} \
}
#define maxe(a) *max_element(a.begin(), a.end())
#define maxi(a) max_element(a.begin(), a.end()) - a.begin()
#define mine(a) *min_element(a.begin(), a.end())
#define mini(a) min_element(a.begin(), a.end()) - a.begin()
#define all(c) c.begin(), c.end()
#define trav(container, it) \
for (typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define present(container, element) (container.find(element) != container.end())
#define cpresent(container, element) \
(find(all(container), element) != \
container.end()) // check the presence of element
// copy(from_begin, from_end, to_begin); copy function
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<ll, ll> p64;
typedef pair<int, int> p32;
typedef pair<int, p32> p96;
typedef vector<ll> v64;
typedef vector<string> vs;
typedef vector<int> v32;
typedef vector<v32> vv32;
typedef vector<v64> vv64;
typedef vector<p32> vp32;
typedef vector<p64> vp64;
typedef vector<vp32> vvp32;
typedef map<int, int> m32;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
#define sumv(v) accumulate(all(v), ll(0))
#define productv(v) accumulate(all(v), ll(1), multiplies<ll>())
ll dp[100003];
ll n, m;
v64 v[100003];
ll solve(ll i) {
if (dp[i] != -1)
return dp[i];
ll maxx = 0;
for (ll j = 0; j < v[i].size(); j++) {
maxx = max(maxx, solve(v[i][j]) + 1);
}
dp[i] = maxx;
return maxx;
}
int main() {
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll x, y;
cin >> x >> y;
v[x].pb(y);
}
fillv(dp, -1);
ll maxx = 0;
for (ll i = 1; i <= n; i++) {
if (dp[i] == -1)
dp[i] = solve(i);
maxx = max(dp[i], maxx);
}
cout << maxx << endl;
}
|
insert
| 84 | 84 | 84 | 85 |
TLE
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.